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 #ifdef SUPPORTD3D
  32 #include <d3d9.h>
  33 extern LPDIRECT3DDEVICE9 vid_d3d9dev;
  34 #endif
  35
  36 mempool_t *r_main_mempool;
  37 rtexturepool_t *r_main_texturepool;
  38
  39 static int r_textureframe = 0; ///< used only by R_GetCurrentTexture
  40
  41 static qboolean r_loadnormalmap;
  42 static qboolean r_loadgloss;
  43 qboolean r_loadfog;
  44 static qboolean r_loaddds;
  45 static qboolean r_savedds;
  46
  47 //
  48 // screen size info
  49 //
  50 r_refdef_t r_refdef;
  51
  52 cvar_t r_motionblur = {CVAR_SAVE, "r_motionblur", "0", "motionblur value scale - 0.5 recommended"};
  53 cvar_t r_damageblur = {CVAR_SAVE, "r_damageblur", "0", "motionblur based on damage"};
  54 cvar_t r_motionblur_vmin = {CVAR_SAVE, "r_motionblur_vmin", "300", "minimum influence from velocity"};
  55 cvar_t r_motionblur_vmax = {CVAR_SAVE, "r_motionblur_vmax", "600", "maximum influence from velocity"};
  56 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)"};
  57 cvar_t r_motionblur_vcoeff = {CVAR_SAVE, "r_motionblur_vcoeff", "0.05", "sliding average reaction time for velocity"};
  58 cvar_t r_motionblur_maxblur = {CVAR_SAVE, "r_motionblur_maxblur", "0.88", "cap for motionblur alpha value"};
  59 cvar_t r_motionblur_randomize = {CVAR_SAVE, "r_motionblur_randomize", "0.1", "randomizing coefficient to workaround ghosting"};
  60
  61 // TODO do we want a r_equalize_entities cvar that works on all ents, or would that be a cheat?
  62 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"};
  63 cvar_t r_equalize_entities_minambient = {CVAR_SAVE, "r_equalize_entities_minambient", "0.5", "light equalizing: ensure at least this ambient/diffuse ratio"};
  64 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)"};
  65 cvar_t r_equalize_entities_to = {CVAR_SAVE, "r_equalize_entities_to", "0.8", "light equalizing: target light level"};
  66
  67 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"};
  68 cvar_t r_useinfinitefarclip = {CVAR_SAVE, "r_useinfinitefarclip", "1", "enables use of a special kind of projection matrix that has an extremely large farclip"};
  69 cvar_t r_farclip_base = {0, "r_farclip_base", "65536", "farclip (furthest visible distance) for rendering when r_useinfinitefarclip is 0"};
  70 cvar_t r_farclip_world = {0, "r_farclip_world", "2", "adds map size to farclip multiplied by this value"};
  71 cvar_t r_nearclip = {0, "r_nearclip", "1", "distance from camera of nearclip plane" };
  72 cvar_t r_showbboxes = {0, "r_showbboxes", "0", "shows bounding boxes of server entities, value controls opacity scaling (1 = 10%,  10 = 100%)"};
  73 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)"};
  74 cvar_t r_showtris = {0, "r_showtris", "0", "shows triangle outlines, value controls brightness (can be above 1)"};
  75 cvar_t r_shownormals = {0, "r_shownormals", "0", "shows per-vertex surface normals and tangent vectors for bumpmapped lighting"};
  76 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"};
  77 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"};
  78 cvar_t r_showcollisionbrushes = {0, "r_showcollisionbrushes", "0", "draws collision brushes in quake3 maps (mode 1), mode 2 disables rendering of world (trippy!)"};
  79 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"};
  80 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"};
  81 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"};
  82 cvar_t r_drawportals = {0, "r_drawportals", "0", "shows portals (separating polygons) in world interior in quake1 maps"};
  83 cvar_t r_drawentities = {0, "r_drawentities","1", "draw entities (doors, players, projectiles, etc)"};
  84 cvar_t r_draw2d = {0, "r_draw2d","1", "draw 2D stuff (dangerous to turn off)"};
  85 cvar_t r_drawworld = {0, "r_drawworld","1", "draw world (most static stuff)"};
  86 cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1", "draw your weapon model"};
  87 cvar_t r_drawexteriormodel = {0, "r_drawexteriormodel","1", "draw your player model (e.g. in chase cam, reflections)"};
  88 cvar_t r_cullentities_trace = {0, "r_cullentities_trace", "1", "probabistically cull invisible entities"};
  89 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)"};
  90 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)"};
  91 cvar_t r_cullentities_trace_enlarge = {0, "r_cullentities_trace_enlarge", "0", "box enlargement for entity culling"};
  92 cvar_t r_cullentities_trace_delay = {0, "r_cullentities_trace_delay", "1", "number of seconds until the entity gets actually culled"};
  93 cvar_t r_speeds = {0, "r_speeds","0", "displays rendering statistics and per-subsystem timings"};
  94 cvar_t r_fullbright = {0, "r_fullbright","0", "makes map very bright and renders faster"};
  95
  96 cvar_t r_fakelight = {0, "r_fakelight","0", "render 'fake' lighting instead of real lightmaps"};
  97 cvar_t r_fakelight_intensity = {0, "r_fakelight_intensity","0.75", "fakelight intensity modifier"};
  98 #define FAKELIGHT_ENABLED (r_fakelight.integer >= 2 || (r_fakelight.integer && r_refdef.scene.worldmodel && !r_refdef.scene.worldmodel->lit))
  99
 100 cvar_t r_wateralpha = {CVAR_SAVE, "r_wateralpha","1", "opacity of water polygons"};
 101 cvar_t r_dynamic = {CVAR_SAVE, "r_dynamic","1", "enables dynamic lights (rocket glow and such)"};
 102 cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1", "enables glowing pixels in quake textures (changes need r_restart to take effect)"};
 103 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."};
 104 cvar_t r_shadows_darken = {CVAR_SAVE, "r_shadows_darken", "0.5", "how much shadowed areas will be darkened"};
 105 cvar_t r_shadows_throwdistance = {CVAR_SAVE, "r_shadows_throwdistance", "500", "how far to cast shadows from models"};
 106 cvar_t r_shadows_throwdirection = {CVAR_SAVE, "r_shadows_throwdirection", "0 0 -1", "override throwing direction for r_shadows 2"};
 107 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."};
 108 cvar_t r_shadows_castfrombmodels = {CVAR_SAVE, "r_shadows_castfrombmodels", "0", "do cast shadows from bmodels"};
 109 cvar_t r_shadows_focus = {CVAR_SAVE, "r_shadows_focus", "0 0 0", "offset the shadowed area focus"};
 110 cvar_t r_shadows_shadowmapscale = {CVAR_SAVE, "r_shadows_shadowmapscale", "1", "increases shadowmap quality (multiply global shadowmap precision) for fake shadows. Needs shadowmapping ON."};
 111 cvar_t r_q1bsp_skymasking = {0, "r_q1bsp_skymasking", "1", "allows sky polygons in quake1 maps to obscure other geometry"};
 112 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"};
 113 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"};
 114 cvar_t r_polygonoffset_decals_factor = {0, "r_polygonoffset_decals_factor", "0", "biases depth values of decals to prevent z-fighting artifacts"};
 115 cvar_t r_polygonoffset_decals_offset = {0, "r_polygonoffset_decals_offset", "-14", "biases depth values of decals to prevent z-fighting artifacts"};
 116 cvar_t r_fog_exp2 = {0, "r_fog_exp2", "0", "uses GL_EXP2 fog (as in Nehahra) rather than realistic GL_EXP fog"};
 117 cvar_t r_drawfog = {CVAR_SAVE, "r_drawfog", "1", "allows one to disable fog rendering"};
 118 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"};
 119
 120 cvar_t gl_fogenable = {0, "gl_fogenable", "0", "nehahra fog enable (for Nehahra compatibility only)"};
 121 cvar_t gl_fogdensity = {0, "gl_fogdensity", "0.25", "nehahra fog density (recommend values below 0.1) (for Nehahra compatibility only)"};
 122 cvar_t gl_fogred = {0, "gl_fogred","0.3", "nehahra fog color red value (for Nehahra compatibility only)"};
 123 cvar_t gl_foggreen = {0, "gl_foggreen","0.3", "nehahra fog color green value (for Nehahra compatibility only)"};
 124 cvar_t gl_fogblue = {0, "gl_fogblue","0.3", "nehahra fog color blue value (for Nehahra compatibility only)"};
 125 cvar_t gl_fogstart = {0, "gl_fogstart", "0", "nehahra fog start distance (for Nehahra compatibility only)"};
 126 cvar_t gl_fogend = {0, "gl_fogend","0", "nehahra fog end distance (for Nehahra compatibility only)"};
 127 cvar_t gl_skyclip = {0, "gl_skyclip", "4608", "nehahra farclip distance - the real fog end (for Nehahra compatibility only)"};
 128
 129 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)"};
 130 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"};
 131
 132 cvar_t r_texture_convertsRGB_2d = {0, "r_texture_convertsRGB_2d", "0", "load textures as sRGB and convert to linear for proper shading"};
 133 cvar_t r_texture_convertsRGB_skin = {0, "r_texture_convertsRGB_skin", "0", "load textures as sRGB and convert to linear for proper shading"};
 134 cvar_t r_texture_convertsRGB_cubemap = {0, "r_texture_convertsRGB_cubemap", "0", "load textures as sRGB and convert to linear for proper shading"};
 135 cvar_t r_texture_convertsRGB_skybox = {0, "r_texture_convertsRGB_skybox", "0", "load textures as sRGB and convert to linear for proper shading"};
 136 cvar_t r_texture_convertsRGB_particles = {0, "r_texture_convertsRGB_particles", "0", "load textures as sRGB and convert to linear for proper shading"};
 137
 138 cvar_t r_textureunits = {0, "r_textureunits", "32", "number of texture units to use in GL 1.1 and GL 1.3 rendering paths"};
 139 static cvar_t gl_combine = {CVAR_READONLY, "gl_combine", "1", "indicates whether the OpenGL 1.3 rendering path is active"};
 140 static cvar_t r_glsl = {CVAR_READONLY, "r_glsl", "1", "indicates whether the OpenGL 2.0 rendering path is active"};
 141
 142 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)"};
 143 cvar_t r_glsl_offsetmapping = {CVAR_SAVE, "r_glsl_offsetmapping", "0", "offset mapping effect (also known as parallax mapping or virtual displacement mapping)"};
 144 cvar_t r_glsl_offsetmapping_reliefmapping = {CVAR_SAVE, "r_glsl_offsetmapping_reliefmapping", "0", "relief mapping effect (higher quality)"};
 145 cvar_t r_glsl_offsetmapping_scale = {CVAR_SAVE, "r_glsl_offsetmapping_scale", "0.04", "how deep the offset mapping effect is"};
 146 cvar_t r_glsl_postprocess = {CVAR_SAVE, "r_glsl_postprocess", "0", "use a GLSL postprocessing shader"};
 147 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)"};
 148 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)"};
 149 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)"};
 150 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)"};
 151
 152 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)"};
 153 cvar_t r_water_clippingplanebias = {CVAR_SAVE, "r_water_clippingplanebias", "1", "a rather technical setting which avoids black pixels around water edges"};
 154 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"};
 155 cvar_t r_water_refractdistort = {CVAR_SAVE, "r_water_refractdistort", "0.01", "how much water refractions shimmer"};
 156 cvar_t r_water_reflectdistort = {CVAR_SAVE, "r_water_reflectdistort", "0.01", "how much water reflections shimmer"};
 157 cvar_t r_water_scissormode = {0, "r_water_scissormode", "3", "scissor (1) or cull (2) or both (3) water renders"};
 158
 159 cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "0", "enables animation smoothing on sprites"};
 160 cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1", "enables animation smoothing on models"};
 161 cvar_t r_lerplightstyles = {CVAR_SAVE, "r_lerplightstyles", "0", "enable animation smoothing on flickering lights"};
 162 cvar_t r_waterscroll = {CVAR_SAVE, "r_waterscroll", "1", "makes water scroll around, value controls how much"};
 163
 164 cvar_t r_bloom = {CVAR_SAVE, "r_bloom", "0", "enables bloom effect (makes bright pixels affect neighboring pixels)"};
 165 cvar_t r_bloom_colorscale = {CVAR_SAVE, "r_bloom_colorscale", "1", "how bright the glow is"};
 166 cvar_t r_bloom_brighten = {CVAR_SAVE, "r_bloom_brighten", "2", "how bright the glow is, after subtract/power"};
 167 cvar_t r_bloom_blur = {CVAR_SAVE, "r_bloom_blur", "4", "how large the glow is"};
 168 cvar_t r_bloom_resolution = {CVAR_SAVE, "r_bloom_resolution", "320", "what resolution to perform the bloom effect at (independent of screen resolution)"};
 169 cvar_t r_bloom_colorexponent = {CVAR_SAVE, "r_bloom_colorexponent", "1", "how exagerated the glow is"};
 170 cvar_t r_bloom_colorsubtract = {CVAR_SAVE, "r_bloom_colorsubtract", "0.125", "reduces bloom colors by a certain amount"};
 171
 172 cvar_t r_hdr = {CVAR_SAVE, "r_hdr", "0", "enables High Dynamic Range bloom effect (higher quality version of r_bloom)"};
 173 cvar_t r_hdr_scenebrightness = {CVAR_SAVE, "r_hdr_scenebrightness", "1", "global rendering brightness"};
 174 cvar_t r_hdr_glowintensity = {CVAR_SAVE, "r_hdr_glowintensity", "1", "how bright light emitting textures should appear"};
 175 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)"};
 176
 177 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"};
 178
 179 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"};
 180
 181 cvar_t gl_lightmaps = {0, "gl_lightmaps", "0", "draws only lightmaps, no texture (for level designers)"};
 182
 183 cvar_t r_test = {0, "r_test", "0", "internal development use only, leave it alone (usually does nothing anyway)"};
 184 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"};
 185 cvar_t r_track_sprites_flags = {CVAR_SAVE, "r_track_sprites_flags", "1", "1: Rotate sprites accodringly, 2: Make it a continuous rotation"};
 186 cvar_t r_track_sprites_scalew = {CVAR_SAVE, "r_track_sprites_scalew", "1", "width scaling of tracked sprites"};
 187 cvar_t r_track_sprites_scaleh = {CVAR_SAVE, "r_track_sprites_scaleh", "1", "height scaling of tracked sprites"};
 188 cvar_t r_overheadsprites_perspective = {CVAR_SAVE, "r_overheadsprites_perspective", "0.15", "fake perspective effect for SPR_OVERHEAD sprites"};
 189 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)"};
 190
 191 cvar_t r_glsl_saturation = {CVAR_SAVE, "r_glsl_saturation", "1", "saturation multiplier (only working in glsl!)"};
 192 cvar_t r_glsl_saturation_redcompensate = {CVAR_SAVE, "r_glsl_saturation_redcompensate", "0", "a 'vampire sight' addition to desaturation effect, does compensation for red color, r_glsl_restart is required"};
 193
 194 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)"};
 195
 196 extern cvar_t v_glslgamma;
 197
 198 extern qboolean v_flipped_state;
 199
 200 static struct r_bloomstate_s
 201 {
 202         qboolean enabled;
 203         qboolean hdr;
 204
 205         int bloomwidth, bloomheight;
 206
 207         int screentexturewidth, screentextureheight;
 208         rtexture_t *texture_screen; /// \note also used for motion blur if enabled!
 209
 210         int bloomtexturewidth, bloomtextureheight;
 211         rtexture_t *texture_bloom;
 212
 213         // arrays for rendering the screen passes
 214         float screentexcoord2f[8];
 215         float bloomtexcoord2f[8];
 216         float offsettexcoord2f[8];
 217
 218         r_viewport_t viewport;
 219 }
 220 r_bloomstate;
 221
 222 r_waterstate_t r_waterstate;
 223
 224 /// shadow volume bsp struct with automatically growing nodes buffer
 225 svbsp_t r_svbsp;
 226
 227 rtexture_t *r_texture_blanknormalmap;
 228 rtexture_t *r_texture_white;
 229 rtexture_t *r_texture_grey128;
 230 rtexture_t *r_texture_black;
 231 rtexture_t *r_texture_notexture;
 232 rtexture_t *r_texture_whitecube;
 233 rtexture_t *r_texture_normalizationcube;
 234 rtexture_t *r_texture_fogattenuation;
 235 rtexture_t *r_texture_fogheighttexture;
 236 rtexture_t *r_texture_gammaramps;
 237 unsigned int r_texture_gammaramps_serial;
 238 //rtexture_t *r_texture_fogintensity;
 239 rtexture_t *r_texture_reflectcube;
 240
 241 // TODO: hash lookups?
 242 typedef struct cubemapinfo_s
 243 {
 244         char basename[64];
 245         rtexture_t *texture;
 246 }
 247 cubemapinfo_t;
 248
 249 int r_texture_numcubemaps;
 250 cubemapinfo_t r_texture_cubemaps[MAX_CUBEMAPS];
 251
 252 unsigned int r_queries[MAX_OCCLUSION_QUERIES];
 253 unsigned int r_numqueries;
 254 unsigned int r_maxqueries;
 255
 256 typedef struct r_qwskincache_s
 257 {
 258         char name[MAX_QPATH];
 259         skinframe_t *skinframe;
 260 }
 261 r_qwskincache_t;
 262
 263 static r_qwskincache_t *r_qwskincache;
 264 static int r_qwskincache_size;
 265
 266 /// vertex coordinates for a quad that covers the screen exactly
 267 extern const float r_screenvertex3f[12];
 268 extern const float r_d3dscreenvertex3f[12];
 269 const float r_screenvertex3f[12] =
 270 {
 271         0, 0, 0,
 272         1, 0, 0,
 273         1, 1, 0,
 274         0, 1, 0
 275 };
 276 const float r_d3dscreenvertex3f[12] =
 277 {
 278         0, 1, 0,
 279         1, 1, 0,
 280         1, 0, 0,
 281         0, 0, 0
 282 };
 283
 284 void R_ModulateColors(float *in, float *out, int verts, float r, float g, float b)
 285 {
 286         int i;
 287         for (i = 0;i < verts;i++)
 288         {
 289                 out[0] = in[0] * r;
 290                 out[1] = in[1] * g;
 291                 out[2] = in[2] * b;
 292                 out[3] = in[3];
 293                 in += 4;
 294                 out += 4;
 295         }
 296 }
 297
 298 void R_FillColors(float *out, int verts, float r, float g, float b, float a)
 299 {
 300         int i;
 301         for (i = 0;i < verts;i++)
 302         {
 303                 out[0] = r;
 304                 out[1] = g;
 305                 out[2] = b;
 306                 out[3] = a;
 307                 out += 4;
 308         }
 309 }
 310
 311 // FIXME: move this to client?
 312 void FOG_clear(void)
 313 {
 314         if (gamemode == GAME_NEHAHRA)
 315         {
 316                 Cvar_Set("gl_fogenable", "0");
 317                 Cvar_Set("gl_fogdensity", "0.2");
 318                 Cvar_Set("gl_fogred", "0.3");
 319                 Cvar_Set("gl_foggreen", "0.3");
 320                 Cvar_Set("gl_fogblue", "0.3");
 321         }
 322         r_refdef.fog_density = 0;
 323         r_refdef.fog_red = 0;
 324         r_refdef.fog_green = 0;
 325         r_refdef.fog_blue = 0;
 326         r_refdef.fog_alpha = 1;
 327         r_refdef.fog_start = 0;
 328         r_refdef.fog_end = 16384;
 329         r_refdef.fog_height = 1<<30;
 330         r_refdef.fog_fadedepth = 128;
 331         memset(r_refdef.fog_height_texturename, 0, sizeof(r_refdef.fog_height_texturename));
 332 }
 333
 334 static void R_BuildBlankTextures(void)
 335 {
 336         unsigned char data[4];
 337         data[2] = 128; // normal X
 338         data[1] = 128; // normal Y
 339         data[0] = 255; // normal Z
 340         data[3] = 128; // height
 341         r_texture_blanknormalmap = R_LoadTexture2D(r_main_texturepool, "blankbump", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, -1, NULL);
 342         data[0] = 255;
 343         data[1] = 255;
 344         data[2] = 255;
 345         data[3] = 255;
 346         r_texture_white = R_LoadTexture2D(r_main_texturepool, "blankwhite", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, -1, NULL);
 347         data[0] = 128;
 348         data[1] = 128;
 349         data[2] = 128;
 350         data[3] = 255;
 351         r_texture_grey128 = R_LoadTexture2D(r_main_texturepool, "blankgrey128", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, -1, NULL);
 352         data[0] = 0;
 353         data[1] = 0;
 354         data[2] = 0;
 355         data[3] = 255;
 356         r_texture_black = R_LoadTexture2D(r_main_texturepool, "blankblack", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, -1, NULL);
 357 }
 358
 359 static void R_BuildNoTexture(void)
 360 {
 361         int x, y;
 362         unsigned char pix[16][16][4];
 363         // this makes a light grey/dark grey checkerboard texture
 364         for (y = 0;y < 16;y++)
 365         {
 366                 for (x = 0;x < 16;x++)
 367                 {
 368                         if ((y < 8) ^ (x < 8))
 369                         {
 370                                 pix[y][x][0] = 128;
 371                                 pix[y][x][1] = 128;
 372                                 pix[y][x][2] = 128;
 373                                 pix[y][x][3] = 255;
 374                         }
 375                         else
 376                         {
 377                                 pix[y][x][0] = 64;
 378                                 pix[y][x][1] = 64;
 379                                 pix[y][x][2] = 64;
 380                                 pix[y][x][3] = 255;
 381                         }
 382                 }
 383         }
 384         r_texture_notexture = R_LoadTexture2D(r_main_texturepool, "notexture", 16, 16, &pix[0][0][0], TEXTYPE_BGRA, TEXF_MIPMAP | TEXF_PERSISTENT, -1, NULL);
 385 }
 386
 387 static void R_BuildWhiteCube(void)
 388 {
 389         unsigned char data[6*1*1*4];
 390         memset(data, 255, sizeof(data));
 391         r_texture_whitecube = R_LoadTextureCubeMap(r_main_texturepool, "whitecube", 1, data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL);
 392 }
 393
 394 static void R_BuildNormalizationCube(void)
 395 {
 396         int x, y, side;
 397         vec3_t v;
 398         vec_t s, t, intensity;
 399 #define NORMSIZE 64
 400         unsigned char *data;
 401         data = (unsigned char *)Mem_Alloc(tempmempool, 6*NORMSIZE*NORMSIZE*4);
 402         for (side = 0;side < 6;side++)
 403         {
 404                 for (y = 0;y < NORMSIZE;y++)
 405                 {
 406                         for (x = 0;x < NORMSIZE;x++)
 407                         {
 408                                 s = (x + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
 409                                 t = (y + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
 410                                 switch(side)
 411                                 {
 412                                 default:
 413                                 case 0:
 414                                         v[0] = 1;
 415                                         v[1] = -t;
 416                                         v[2] = -s;
 417                                         break;
 418                                 case 1:
 419                                         v[0] = -1;
 420                                         v[1] = -t;
 421                                         v[2] = s;
 422                                         break;
 423                                 case 2:
 424                                         v[0] = s;
 425                                         v[1] = 1;
 426                                         v[2] = t;
 427                                         break;
 428                                 case 3:
 429                                         v[0] = s;
 430                                         v[1] = -1;
 431                                         v[2] = -t;
 432                                         break;
 433                                 case 4:
 434                                         v[0] = s;
 435                                         v[1] = -t;
 436                                         v[2] = 1;
 437                                         break;
 438                                 case 5:
 439                                         v[0] = -s;
 440                                         v[1] = -t;
 441                                         v[2] = -1;
 442                                         break;
 443                                 }
 444                                 intensity = 127.0f / sqrt(DotProduct(v, v));
 445                                 data[((side*64+y)*64+x)*4+2] = (unsigned char)(128.0f + intensity * v[0]);
 446                                 data[((side*64+y)*64+x)*4+1] = (unsigned char)(128.0f + intensity * v[1]);
 447                                 data[((side*64+y)*64+x)*4+0] = (unsigned char)(128.0f + intensity * v[2]);
 448                                 data[((side*64+y)*64+x)*4+3] = 255;
 449                         }
 450                 }
 451         }
 452         r_texture_normalizationcube = R_LoadTextureCubeMap(r_main_texturepool, "normalcube", NORMSIZE, data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL);
 453         Mem_Free(data);
 454 }
 455
 456 static void R_BuildFogTexture(void)
 457 {
 458         int x, b;
 459 #define FOGWIDTH 256
 460         unsigned char data1[FOGWIDTH][4];
 461         //unsigned char data2[FOGWIDTH][4];
 462         double d, r, alpha;
 463
 464         r_refdef.fogmasktable_start = r_refdef.fog_start;
 465         r_refdef.fogmasktable_alpha = r_refdef.fog_alpha;
 466         r_refdef.fogmasktable_range = r_refdef.fogrange;
 467         r_refdef.fogmasktable_density = r_refdef.fog_density;
 468
 469         r = r_refdef.fogmasktable_range / FOGMASKTABLEWIDTH;
 470         for (x = 0;x < FOGMASKTABLEWIDTH;x++)
 471         {
 472                 d = (x * r - r_refdef.fogmasktable_start);
 473                 if(developer_extra.integer)
 474                         Con_DPrintf("%f ", d);
 475                 d = max(0, d);
 476                 if (r_fog_exp2.integer)
 477                         alpha = exp(-r_refdef.fogmasktable_density * r_refdef.fogmasktable_density * 0.0001 * d * d);
 478                 else
 479                         alpha = exp(-r_refdef.fogmasktable_density * 0.004 * d);
 480                 if(developer_extra.integer)
 481                         Con_DPrintf(" : %f ", alpha);
 482                 alpha = 1 - (1 - alpha) * r_refdef.fogmasktable_alpha;
 483                 if(developer_extra.integer)
 484                         Con_DPrintf(" = %f\n", alpha);
 485                 r_refdef.fogmasktable[x] = bound(0, alpha, 1);
 486         }
 487
 488         for (x = 0;x < FOGWIDTH;x++)
 489         {
 490                 b = (int)(r_refdef.fogmasktable[x * (FOGMASKTABLEWIDTH - 1) / (FOGWIDTH - 1)] * 255);
 491                 data1[x][0] = b;
 492                 data1[x][1] = b;
 493                 data1[x][2] = b;
 494                 data1[x][3] = 255;
 495                 //data2[x][0] = 255 - b;
 496                 //data2[x][1] = 255 - b;
 497                 //data2[x][2] = 255 - b;
 498                 //data2[x][3] = 255;
 499         }
 500         if (r_texture_fogattenuation)
 501         {
 502                 R_UpdateTexture(r_texture_fogattenuation, &data1[0][0], 0, 0, FOGWIDTH, 1);
 503                 //R_UpdateTexture(r_texture_fogattenuation, &data2[0][0], 0, 0, FOGWIDTH, 1);
 504         }
 505         else
 506         {
 507                 r_texture_fogattenuation = R_LoadTexture2D(r_main_texturepool, "fogattenuation", FOGWIDTH, 1, &data1[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL);
 508                 //r_texture_fogintensity = R_LoadTexture2D(r_main_texturepool, "fogintensity", FOGWIDTH, 1, &data2[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP, NULL);
 509         }
 510 }
 511
 512 static void R_BuildFogHeightTexture(void)
 513 {
 514         unsigned char *inpixels;
 515         int size;
 516         int x;
 517         int y;
 518         int j;
 519         float c[4];
 520         float f;
 521         inpixels = NULL;
 522         strlcpy(r_refdef.fogheighttexturename, r_refdef.fog_height_texturename, sizeof(r_refdef.fogheighttexturename));
 523         if (r_refdef.fogheighttexturename[0])
 524                 inpixels = loadimagepixelsbgra(r_refdef.fogheighttexturename, true, false, false, NULL);
 525         if (!inpixels)
 526         {
 527                 r_refdef.fog_height_tablesize = 0;
 528                 if (r_texture_fogheighttexture)
 529                         R_FreeTexture(r_texture_fogheighttexture);
 530                 r_texture_fogheighttexture = NULL;
 531                 if (r_refdef.fog_height_table2d)
 532                         Mem_Free(r_refdef.fog_height_table2d);
 533                 r_refdef.fog_height_table2d = NULL;
 534                 if (r_refdef.fog_height_table1d)
 535                         Mem_Free(r_refdef.fog_height_table1d);
 536                 r_refdef.fog_height_table1d = NULL;
 537                 return;
 538         }
 539         size = image_width;
 540         r_refdef.fog_height_tablesize = size;
 541         r_refdef.fog_height_table1d = (unsigned char *)Mem_Alloc(r_main_mempool, size * 4);
 542         r_refdef.fog_height_table2d = (unsigned char *)Mem_Alloc(r_main_mempool, size * size * 4);
 543         memcpy(r_refdef.fog_height_table1d, inpixels, size * 4);
 544         Mem_Free(inpixels);
 545         // LordHavoc: now the magic - what is that table2d for?  it is a cooked
 546         // average fog color table accounting for every fog layer between a point
 547         // and the camera.  (Note: attenuation is handled separately!)
 548         for (y = 0;y < size;y++)
 549         {
 550                 for (x = 0;x < size;x++)
 551                 {
 552                         Vector4Clear(c);
 553                         f = 0;
 554                         if (x < y)
 555                         {
 556                                 for (j = x;j <= y;j++)
 557                                 {
 558                                         Vector4Add(c, r_refdef.fog_height_table1d + j*4, c);
 559                                         f++;
 560                                 }
 561                         }
 562                         else
 563                         {
 564                                 for (j = x;j >= y;j--)
 565                                 {
 566                                         Vector4Add(c, r_refdef.fog_height_table1d + j*4, c);
 567                                         f++;
 568                                 }
 569                         }
 570                         f = 1.0f / f;
 571                         r_refdef.fog_height_table2d[(y*size+x)*4+0] = (unsigned char)(c[0] * f);
 572                         r_refdef.fog_height_table2d[(y*size+x)*4+1] = (unsigned char)(c[1] * f);
 573                         r_refdef.fog_height_table2d[(y*size+x)*4+2] = (unsigned char)(c[2] * f);
 574                         r_refdef.fog_height_table2d[(y*size+x)*4+3] = (unsigned char)(c[3] * f);
 575                 }
 576         }
 577         r_texture_fogheighttexture = R_LoadTexture2D(r_main_texturepool, "fogheighttable", size, size, r_refdef.fog_height_table2d, TEXTYPE_BGRA, TEXF_ALPHA | TEXF_CLAMP, -1, NULL);
 578 }
 579
 580 //=======================================================================================================================================================
 581
 582 static const char *builtinshaderstring =
 583 "// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
 584 "// written by Forest 'LordHavoc' Hale\n"
 585 "// shadowmapping enhancements by Lee 'eihrul' Salzman\n"
 586 "\n"
 587 "#if defined(USEFOGINSIDE) || defined(USEFOGOUTSIDE) || defined(USEFOGHEIGHTTEXTURE)\n"
 588 "# define USEFOG\n"
 589 "#endif\n"
 590 "#if defined(MODE_LIGHTMAP) || defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
 591 "#define USELIGHTMAP\n"
 592 "#endif\n"
 593 "#if defined(USESPECULAR) || defined(USEOFFSETMAPPING) || defined(USEREFLECTCUBE) || defined(MODE_FAKELIGHT)\n"
 594 "#define USEEYEVECTOR\n"
 595 "#endif\n"
 596 "\n"
 597 "#ifdef USESHADOWMAP2D\n"
 598 "# ifdef GL_EXT_gpu_shader4\n"
 599 "#   extension GL_EXT_gpu_shader4 : enable\n"
 600 "# endif\n"
 601 "# ifdef GL_ARB_texture_gather\n"
 602 "#   extension GL_ARB_texture_gather : enable\n"
 603 "# else\n"
 604 "#   ifdef GL_AMD_texture_texture4\n"
 605 "#     extension GL_AMD_texture_texture4 : enable\n"
 606 "#   endif\n"
 607 "# endif\n"
 608 "#endif\n"
 609 "\n"
 610 "//#ifdef USESHADOWSAMPLER\n"
 611 "//# extension GL_ARB_shadow : enable\n"
 612 "//#endif\n"
 613 "\n"
 614 "//#ifdef __GLSL_CG_DATA_TYPES\n"
 615 "//# define myhalf half\n"
 616 "//# define myhalf2 half2\n"
 617 "//# define myhalf3 half3\n"
 618 "//# define myhalf4 half4\n"
 619 "//#else\n"
 620 "# define myhalf float\n"
 621 "# define myhalf2 vec2\n"
 622 "# define myhalf3 vec3\n"
 623 "# define myhalf4 vec4\n"
 624 "//#endif\n"
 625 "\n"
 626 "#ifdef VERTEX_SHADER\n"
 627 "uniform mat4 ModelViewProjectionMatrix;\n"
 628 "#endif\n"
 629 "\n"
 630 "#ifdef MODE_DEPTH_OR_SHADOW\n"
 631 "#ifdef VERTEX_SHADER\n"
 632 "void main(void)\n"
 633 "{\n"
 634 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 635 "}\n"
 636 "#endif\n"
 637 "#else // !MODE_DEPTH_ORSHADOW\n"
 638 "\n"
 639 "\n"
 640 "\n"
 641 "\n"
 642 "#ifdef MODE_SHOWDEPTH\n"
 643 "#ifdef VERTEX_SHADER\n"
 644 "void main(void)\n"
 645 "{\n"
 646 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 647 "       gl_FrontColor = vec4(gl_Position.z, gl_Position.z, gl_Position.z, 1.0);\n"
 648 "}\n"
 649 "#endif\n"
 650 "\n"
 651 "#ifdef FRAGMENT_SHADER\n"
 652 "void main(void)\n"
 653 "{\n"
 654 "       gl_FragColor = gl_Color;\n"
 655 "}\n"
 656 "#endif\n"
 657 "#else // !MODE_SHOWDEPTH\n"
 658 "\n"
 659 "\n"
 660 "\n"
 661 "\n"
 662 "#ifdef MODE_POSTPROCESS\n"
 663 "varying vec2 TexCoord1;\n"
 664 "varying vec2 TexCoord2;\n"
 665 "\n"
 666 "#ifdef VERTEX_SHADER\n"
 667 "void main(void)\n"
 668 "{\n"
 669 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 670 "       TexCoord1 = gl_MultiTexCoord0.xy;\n"
 671 "#ifdef USEBLOOM\n"
 672 "       TexCoord2 = gl_MultiTexCoord4.xy;\n"
 673 "#endif\n"
 674 "}\n"
 675 "#endif\n"
 676 "\n"
 677 "#ifdef FRAGMENT_SHADER\n"
 678 "uniform sampler2D Texture_First;\n"
 679 "#ifdef USEBLOOM\n"
 680 "uniform sampler2D Texture_Second;\n"
 681 "uniform vec4 BloomColorSubtract;\n"
 682 "#endif\n"
 683 "#ifdef USEGAMMARAMPS\n"
 684 "uniform sampler2D Texture_GammaRamps;\n"
 685 "#endif\n"
 686 "#ifdef USESATURATION\n"
 687 "uniform float Saturation;\n"
 688 "#endif\n"
 689 "#ifdef USEVIEWTINT\n"
 690 "uniform vec4 ViewTintColor;\n"
 691 "#endif\n"
 692 "//uncomment these if you want to use them:\n"
 693 "uniform vec4 UserVec1;\n"
 694 "uniform vec4 UserVec2;\n"
 695 "// uniform vec4 UserVec3;\n"
 696 "// uniform vec4 UserVec4;\n"
 697 "// uniform float ClientTime;\n"
 698 "uniform vec2 PixelSize;\n"
 699 "void main(void)\n"
 700 "{\n"
 701 "       gl_FragColor = texture2D(Texture_First, TexCoord1);\n"
 702 "#ifdef USEBLOOM\n"
 703 "       gl_FragColor += max(vec4(0,0,0,0), texture2D(Texture_Second, TexCoord2) - BloomColorSubtract);\n"
 704 "#endif\n"
 705 "#ifdef USEVIEWTINT\n"
 706 "       gl_FragColor = mix(gl_FragColor, ViewTintColor, ViewTintColor.a);\n"
 707 "#endif\n"
 708 "\n"
 709 "#ifdef USEPOSTPROCESSING\n"
 710 "// do r_glsl_dumpshader, edit glsl/default.glsl, and replace this by your own postprocessing if you want\n"
 711 "// 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"
 712 "       float sobel = 1.0;\n"
 713 "       // vec2 ts = textureSize(Texture_First, 0);\n"
 714 "       // vec2 px = vec2(1/ts.x, 1/ts.y);\n"
 715 "       vec2 px = PixelSize;\n"
 716 "       vec3 x1 = texture2D(Texture_First, TexCoord1 + vec2(-px.x, px.y)).rgb;\n"
 717 "       vec3 x2 = texture2D(Texture_First, TexCoord1 + vec2(-px.x,  0.0)).rgb;\n"
 718 "       vec3 x3 = texture2D(Texture_First, TexCoord1 + vec2(-px.x,-px.y)).rgb;\n"
 719 "       vec3 x4 = texture2D(Texture_First, TexCoord1 + vec2( px.x, px.y)).rgb;\n"
 720 "       vec3 x5 = texture2D(Texture_First, TexCoord1 + vec2( px.x,  0.0)).rgb;\n"
 721 "       vec3 x6 = texture2D(Texture_First, TexCoord1 + vec2( px.x,-px.y)).rgb;\n"
 722 "       vec3 y1 = texture2D(Texture_First, TexCoord1 + vec2( px.x,-px.y)).rgb;\n"
 723 "       vec3 y2 = texture2D(Texture_First, TexCoord1 + vec2(  0.0,-px.y)).rgb;\n"
 724 "       vec3 y3 = texture2D(Texture_First, TexCoord1 + vec2(-px.x,-px.y)).rgb;\n"
 725 "       vec3 y4 = texture2D(Texture_First, TexCoord1 + vec2( px.x, px.y)).rgb;\n"
 726 "       vec3 y5 = texture2D(Texture_First, TexCoord1 + vec2(  0.0, px.y)).rgb;\n"
 727 "       vec3 y6 = texture2D(Texture_First, TexCoord1 + vec2(-px.x, px.y)).rgb;\n"
 728 "       float px1 = -1.0 * dot(vec3(0.3, 0.59, 0.11), x1);\n"
 729 "       float px2 = -2.0 * dot(vec3(0.3, 0.59, 0.11), x2);\n"
 730 "       float px3 = -1.0 * dot(vec3(0.3, 0.59, 0.11), x3);\n"
 731 "       float px4 =  1.0 * dot(vec3(0.3, 0.59, 0.11), x4);\n"
 732 "       float px5 =  2.0 * dot(vec3(0.3, 0.59, 0.11), x5);\n"
 733 "       float px6 =  1.0 * dot(vec3(0.3, 0.59, 0.11), x6);\n"
 734 "       float py1 = -1.0 * dot(vec3(0.3, 0.59, 0.11), y1);\n"
 735 "       float py2 = -2.0 * dot(vec3(0.3, 0.59, 0.11), y2);\n"
 736 "       float py3 = -1.0 * dot(vec3(0.3, 0.59, 0.11), y3);\n"
 737 "       float py4 =  1.0 * dot(vec3(0.3, 0.59, 0.11), y4);\n"
 738 "       float py5 =  2.0 * dot(vec3(0.3, 0.59, 0.11), y5);\n"
 739 "       float py6 =  1.0 * dot(vec3(0.3, 0.59, 0.11), y6);\n"
 740 "       sobel = 0.25 * abs(px1 + px2 + px3 + px4 + px5 + px6) + 0.25 * abs(py1 + py2 + py3 + py4 + py5 + py6);\n"
 741 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2(-0.987688, -0.156434)) * UserVec1.y;\n"
 742 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2(-0.156434, -0.891007)) * UserVec1.y;\n"
 743 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2( 0.891007, -0.453990)) * UserVec1.y;\n"
 744 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2( 0.707107,  0.707107)) * UserVec1.y;\n"
 745 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2(-0.453990,  0.891007)) * UserVec1.y;\n"
 746 "       gl_FragColor /= (1.0 + 5.0 * UserVec1.y);\n"
 747 "       gl_FragColor.rgb = gl_FragColor.rgb * (1.0 + UserVec2.x) + vec3(max(0.0, sobel - UserVec2.z))*UserVec2.y;\n"
 748 "#endif\n"
 749 "\n"
 750 "#ifdef USESATURATION\n"
 751 "       //apply saturation BEFORE gamma ramps, so v_glslgamma value does not matter\n"
 752 "       float y = dot(gl_FragColor.rgb, vec3(0.299, 0.587, 0.114));\n"
 753 "       // 'vampire sight' effect, wheres red is compensated\n"
 754 "       #ifdef SATURATION_REDCOMPENSATE\n"
 755 "               float rboost = max(0.0, (gl_FragColor.r - max(gl_FragColor.g, gl_FragColor.b))*(1.0 - Saturation));\n"
 756 "               gl_FragColor.rgb = mix(vec3(y), gl_FragColor.rgb, Saturation);\n"
 757 "               gl_FragColor.r += rboost;\n"
 758 "       #else\n"
 759 "               // normal desaturation\n"
 760 "               //gl_FragColor = vec3(y) + (gl_FragColor.rgb - vec3(y)) * Saturation;\n"
 761 "               gl_FragColor.rgb = mix(vec3(y), gl_FragColor.rgb, Saturation);\n"
 762 "       #endif\n"
 763 "#endif\n"
 764 "\n"
 765 "#ifdef USEGAMMARAMPS\n"
 766 "       gl_FragColor.r = texture2D(Texture_GammaRamps, vec2(gl_FragColor.r, 0)).r;\n"
 767 "       gl_FragColor.g = texture2D(Texture_GammaRamps, vec2(gl_FragColor.g, 0)).g;\n"
 768 "       gl_FragColor.b = texture2D(Texture_GammaRamps, vec2(gl_FragColor.b, 0)).b;\n"
 769 "#endif\n"
 770 "}\n"
 771 "#endif\n"
 772 "#else // !MODE_POSTPROCESS\n"
 773 "\n"
 774 "\n"
 775 "\n"
 776 "\n"
 777 "#ifdef MODE_GENERIC\n"
 778 "#ifdef USEDIFFUSE\n"
 779 "varying vec2 TexCoord1;\n"
 780 "#endif\n"
 781 "#ifdef USESPECULAR\n"
 782 "varying vec2 TexCoord2;\n"
 783 "#endif\n"
 784 "#ifdef VERTEX_SHADER\n"
 785 "void main(void)\n"
 786 "{\n"
 787 "       gl_FrontColor = gl_Color;\n"
 788 "#ifdef USEDIFFUSE\n"
 789 "       TexCoord1 = gl_MultiTexCoord0.xy;\n"
 790 "#endif\n"
 791 "#ifdef USESPECULAR\n"
 792 "       TexCoord2 = gl_MultiTexCoord1.xy;\n"
 793 "#endif\n"
 794 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 795 "}\n"
 796 "#endif\n"
 797 "\n"
 798 "#ifdef FRAGMENT_SHADER\n"
 799 "#ifdef USEDIFFUSE\n"
 800 "uniform sampler2D Texture_First;\n"
 801 "#endif\n"
 802 "#ifdef USESPECULAR\n"
 803 "uniform sampler2D Texture_Second;\n"
 804 "#endif\n"
 805 "\n"
 806 "void main(void)\n"
 807 "{\n"
 808 "       gl_FragColor = gl_Color;\n"
 809 "#ifdef USEDIFFUSE\n"
 810 "       gl_FragColor *= texture2D(Texture_First, TexCoord1);\n"
 811 "#endif\n"
 812 "\n"
 813 "#ifdef USESPECULAR\n"
 814 "       vec4 tex2 = texture2D(Texture_Second, TexCoord2);\n"
 815 "# ifdef USECOLORMAPPING\n"
 816 "       gl_FragColor *= tex2;\n"
 817 "# endif\n"
 818 "# ifdef USEGLOW\n"
 819 "       gl_FragColor += tex2;\n"
 820 "# endif\n"
 821 "# ifdef USEVERTEXTEXTUREBLEND\n"
 822 "       gl_FragColor = mix(gl_FragColor, tex2, tex2.a);\n"
 823 "# endif\n"
 824 "#endif\n"
 825 "}\n"
 826 "#endif\n"
 827 "#else // !MODE_GENERIC\n"
 828 "\n"
 829 "\n"
 830 "\n"
 831 "\n"
 832 "#ifdef MODE_BLOOMBLUR\n"
 833 "varying TexCoord;\n"
 834 "#ifdef VERTEX_SHADER\n"
 835 "void main(void)\n"
 836 "{\n"
 837 "       gl_FrontColor = gl_Color;\n"
 838 "       TexCoord = gl_MultiTexCoord0.xy;\n"
 839 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 840 "}\n"
 841 "#endif\n"
 842 "\n"
 843 "#ifdef FRAGMENT_SHADER\n"
 844 "uniform sampler2D Texture_First;\n"
 845 "uniform vec4 BloomBlur_Parameters;\n"
 846 "\n"
 847 "void main(void)\n"
 848 "{\n"
 849 "       int i;\n"
 850 "       vec2 tc = TexCoord;\n"
 851 "       vec3 color = texture2D(Texture_First, tc).rgb;\n"
 852 "       tc += BloomBlur_Parameters.xy;\n"
 853 "       for (i = 1;i < SAMPLES;i++)\n"
 854 "       {\n"
 855 "               color += texture2D(Texture_First, tc).rgb;\n"
 856 "               tc += BloomBlur_Parameters.xy;\n"
 857 "       }\n"
 858 "       gl_FragColor = vec4(color * BloomBlur_Parameters.z + vec3(BloomBlur_Parameters.w), 1);\n"
 859 "}\n"
 860 "#endif\n"
 861 "#else // !MODE_BLOOMBLUR\n"
 862 "#ifdef MODE_REFRACTION\n"
 863 "varying vec2 TexCoord;\n"
 864 "varying vec4 ModelViewProjectionPosition;\n"
 865 "uniform mat4 TexMatrix;\n"
 866 "#ifdef VERTEX_SHADER\n"
 867 "\n"
 868 "void main(void)\n"
 869 "{\n"
 870 "       TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
 871 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 872 "       ModelViewProjectionPosition = gl_Position;\n"
 873 "}\n"
 874 "#endif\n"
 875 "\n"
 876 "#ifdef FRAGMENT_SHADER\n"
 877 "uniform sampler2D Texture_Normal;\n"
 878 "uniform sampler2D Texture_Refraction;\n"
 879 "uniform sampler2D Texture_Reflection;\n"
 880 "\n"
 881 "uniform vec4 DistortScaleRefractReflect;\n"
 882 "uniform vec4 ScreenScaleRefractReflect;\n"
 883 "uniform vec4 ScreenCenterRefractReflect;\n"
 884 "uniform vec4 RefractColor;\n"
 885 "uniform vec4 ReflectColor;\n"
 886 "uniform float ReflectFactor;\n"
 887 "uniform float ReflectOffset;\n"
 888 "\n"
 889 "void main(void)\n"
 890 "{\n"
 891 "       vec2 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect.xy * (1.0 / ModelViewProjectionPosition.w);\n"
 892 "       //vec2 ScreenTexCoord = (ModelViewProjectionPosition.xy + normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5)).xy * DistortScaleRefractReflect.xy * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
 893 "       vec2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
 894 "       vec2 ScreenTexCoord = SafeScreenTexCoord + vec2(normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5))).xy * DistortScaleRefractReflect.xy;\n"
 895 "       // FIXME temporary hack to detect the case that the reflection\n"
 896 "       // gets blackened at edges due to leaving the area that contains actual\n"
 897 "       // content.\n"
 898 "       // Remove this 'ack once we have a better way to stop this thing from\n"
 899 "       // 'appening.\n"
 900 "       float f = min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(0.01, 0.01)).rgb) / 0.05);\n"
 901 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(0.01, -0.01)).rgb) / 0.05);\n"
 902 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
 903 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
 904 "       ScreenTexCoord = mix(SafeScreenTexCoord, ScreenTexCoord, f);\n"
 905 "       gl_FragColor = vec4(texture2D(Texture_Refraction, ScreenTexCoord).rgb, 1.0) * RefractColor;\n"
 906 "}\n"
 907 "#endif\n"
 908 "#else // !MODE_REFRACTION\n"
 909 "\n"
 910 "\n"
 911 "\n"
 912 "\n"
 913 "#ifdef MODE_WATER\n"
 914 "varying vec2 TexCoord;\n"
 915 "varying vec3 EyeVector;\n"
 916 "varying vec4 ModelViewProjectionPosition;\n"
 917 "#ifdef VERTEX_SHADER\n"
 918 "uniform vec3 EyePosition;\n"
 919 "uniform mat4 TexMatrix;\n"
 920 "\n"
 921 "void main(void)\n"
 922 "{\n"
 923 "       TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
 924 "       vec3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
 925 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
 926 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
 927 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
 928 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 929 "       ModelViewProjectionPosition = gl_Position;\n"
 930 "}\n"
 931 "#endif\n"
 932 "\n"
 933 "#ifdef FRAGMENT_SHADER\n"
 934 "uniform sampler2D Texture_Normal;\n"
 935 "uniform sampler2D Texture_Refraction;\n"
 936 "uniform sampler2D Texture_Reflection;\n"
 937 "\n"
 938 "uniform vec4 DistortScaleRefractReflect;\n"
 939 "uniform vec4 ScreenScaleRefractReflect;\n"
 940 "uniform vec4 ScreenCenterRefractReflect;\n"
 941 "uniform vec4 RefractColor;\n"
 942 "uniform vec4 ReflectColor;\n"
 943 "uniform float ReflectFactor;\n"
 944 "uniform float ReflectOffset;\n"
 945 "uniform float ClientTime;\n"
 946 "#ifdef USENORMALMAPSCROLLBLEND\n"
 947 "uniform vec2 NormalmapScrollBlend;\n"
 948 "#endif\n"
 949 "\n"
 950 "void main(void)\n"
 951 "{\n"
 952 "       vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
 953 "       //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
 954 "       vec4 SafeScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
 955 "       //SafeScreenTexCoord = gl_FragCoord.xyxy * vec4(1.0 / 1920.0, 1.0 / 1200.0, 1.0 / 1920.0, 1.0 / 1200.0);\n"
 956 "       // slight water animation via 2 layer scrolling (todo: tweak)\n"
 957 "       #ifdef USENORMALMAPSCROLLBLEND\n"
 958 "               vec3 normal = texture2D(Texture_Normal, (TexCoord + vec2(0.08, 0.08)*ClientTime*NormalmapScrollBlend.x*0.5)*NormalmapScrollBlend.y).rgb - vec3(1.0);\n"
 959 "               normal += texture2D(Texture_Normal, (TexCoord + vec2(-0.06, -0.09)*ClientTime*NormalmapScrollBlend.x)*NormalmapScrollBlend.y*0.75).rgb;\n"
 960 "               vec4 ScreenTexCoord = SafeScreenTexCoord + vec2(normalize(normal) + vec3(0.15)).xyxy * DistortScaleRefractReflect;\n"
 961 "       #else\n"
 962 "               vec4 ScreenTexCoord = SafeScreenTexCoord + vec2(normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5))).xyxy * DistortScaleRefractReflect;\n"
 963 "       #endif\n"
 964 "       // FIXME temporary hack to detect the case that the reflection\n"
 965 "       // gets blackened at edges due to leaving the area that contains actual\n"
 966 "       // content.\n"
 967 "       // Remove this 'ack once we have a better way to stop this thing from\n"
 968 "       // 'appening.\n"
 969 "       float f1 = min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(0.005, 0.01)).rgb) / 0.002);\n"
 970 "       f1      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(0.005, -0.01)).rgb) / 0.002);\n"
 971 "       f1      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(-0.005, 0.01)).rgb) / 0.002);\n"
 972 "       f1      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(-0.005, -0.01)).rgb) / 0.002);\n"
 973 "       ScreenTexCoord.xy = mix(SafeScreenTexCoord.xy, ScreenTexCoord.xy, f1);\n"
 974 "       float f = min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(0.005, 0.005)).rgb) / 0.002);\n"
 975 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(0.005, -0.005)).rgb) / 0.002);\n"
 976 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(-0.005, 0.005)).rgb) / 0.002);\n"
 977 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(-0.005, -0.005)).rgb) / 0.002);\n"
 978 "       ScreenTexCoord.zw = mix(SafeScreenTexCoord.zw, ScreenTexCoord.zw, f);\n"
 979 "       float Fresnel = pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 2.0) * ReflectFactor + ReflectOffset;\n"
 980 "       gl_FragColor = mix(vec4(texture2D(Texture_Refraction, ScreenTexCoord.xy).rgb, 1) * RefractColor, vec4(texture2D(Texture_Reflection, ScreenTexCoord.zw).rgb, 1) * ReflectColor, Fresnel);\n"
 981 "       gl_FragColor.a = f1 + 0.5;\n"
 982 "}\n"
 983 "#endif\n"
 984 "#else // !MODE_WATER\n"
 985 "\n"
 986 "\n"
 987 "\n"
 988 "\n"
 989 "// common definitions between vertex shader and fragment shader:\n"
 990 "\n"
 991 "varying vec2 TexCoord;\n"
 992 "#ifdef USEVERTEXTEXTUREBLEND\n"
 993 "varying vec2 TexCoord2;\n"
 994 "#endif\n"
 995 "#ifdef USELIGHTMAP\n"
 996 "varying vec2 TexCoordLightmap;\n"
 997 "#endif\n"
 998 "\n"
 999 "#ifdef MODE_LIGHTSOURCE\n"
1000 "varying vec3 CubeVector;\n"
1001 "#endif\n"
1002 "\n"
1003 "#if (defined(MODE_LIGHTSOURCE) || defined(MODE_LIGHTDIRECTION)) && defined(USEDIFFUSE)\n"
1004 "varying vec3 LightVector;\n"
1005 "#endif\n"
1006 "\n"
1007 "#ifdef USEEYEVECTOR\n"
1008 "varying vec3 EyeVector;\n"
1009 "#endif\n"
1010 "#ifdef USEFOG\n"
1011 "varying vec4 EyeVectorModelSpaceFogPlaneVertexDist;\n"
1012 "#endif\n"
1013 "\n"
1014 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY) || defined(USEREFLECTCUBE)\n"
1015 "varying vec3 VectorS; // direction of S texcoord (sometimes crudely called tangent)\n"
1016 "varying vec3 VectorT; // direction of T texcoord (sometimes crudely called binormal)\n"
1017 "varying vec3 VectorR; // direction of R texcoord (surface normal)\n"
1018 "#endif\n"
1019 "\n"
1020 "#ifdef USEREFLECTION\n"
1021 "varying vec4 ModelViewProjectionPosition;\n"
1022 "#endif\n"
1023 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
1024 "uniform vec3 LightPosition;\n"
1025 "varying vec4 ModelViewPosition;\n"
1026 "#endif\n"
1027 "\n"
1028 "#ifdef MODE_LIGHTSOURCE\n"
1029 "uniform vec3 LightPosition;\n"
1030 "#endif\n"
1031 "uniform vec3 EyePosition;\n"
1032 "#ifdef MODE_LIGHTDIRECTION\n"
1033 "uniform vec3 LightDir;\n"
1034 "#endif\n"
1035 "uniform vec4 FogPlane;\n"
1036 "\n"
1037 "#ifdef USESHADOWMAPORTHO\n"
1038 "varying vec3 ShadowMapTC;\n"
1039 "#endif\n"
1040 "\n"
1041 "\n"
1042 "\n"
1043 "\n"
1044 "\n"
1045 "// 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"
1046 "\n"
1047 "// fragment shader specific:\n"
1048 "#ifdef FRAGMENT_SHADER\n"
1049 "\n"
1050 "uniform sampler2D Texture_Normal;\n"
1051 "uniform sampler2D Texture_Color;\n"
1052 "uniform sampler2D Texture_Gloss;\n"
1053 "#ifdef USEGLOW\n"
1054 "uniform sampler2D Texture_Glow;\n"
1055 "#endif\n"
1056 "#ifdef USEVERTEXTEXTUREBLEND\n"
1057 "uniform sampler2D Texture_SecondaryNormal;\n"
1058 "uniform sampler2D Texture_SecondaryColor;\n"
1059 "uniform sampler2D Texture_SecondaryGloss;\n"
1060 "#ifdef USEGLOW\n"
1061 "uniform sampler2D Texture_SecondaryGlow;\n"
1062 "#endif\n"
1063 "#endif\n"
1064 "#ifdef USECOLORMAPPING\n"
1065 "uniform sampler2D Texture_Pants;\n"
1066 "uniform sampler2D Texture_Shirt;\n"
1067 "#endif\n"
1068 "#ifdef USEFOG\n"
1069 "#ifdef USEFOGHEIGHTTEXTURE\n"
1070 "uniform sampler2D Texture_FogHeightTexture;\n"
1071 "#endif\n"
1072 "uniform sampler2D Texture_FogMask;\n"
1073 "#endif\n"
1074 "#ifdef USELIGHTMAP\n"
1075 "uniform sampler2D Texture_Lightmap;\n"
1076 "#endif\n"
1077 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
1078 "uniform sampler2D Texture_Deluxemap;\n"
1079 "#endif\n"
1080 "#ifdef USEREFLECTION\n"
1081 "uniform sampler2D Texture_Reflection;\n"
1082 "#endif\n"
1083 "\n"
1084 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
1085 "uniform sampler2D Texture_ScreenDepth;\n"
1086 "uniform sampler2D Texture_ScreenNormalMap;\n"
1087 "#endif\n"
1088 "#ifdef USEDEFERREDLIGHTMAP\n"
1089 "uniform sampler2D Texture_ScreenDiffuse;\n"
1090 "uniform sampler2D Texture_ScreenSpecular;\n"
1091 "#endif\n"
1092 "\n"
1093 "uniform myhalf3 Color_Pants;\n"
1094 "uniform myhalf3 Color_Shirt;\n"
1095 "uniform myhalf3 FogColor;\n"
1096 "\n"
1097 "#ifdef USEFOG\n"
1098 "uniform float FogRangeRecip;\n"
1099 "uniform float FogPlaneViewDist;\n"
1100 "uniform float FogHeightFade;\n"
1101 "vec3 FogVertex(vec3 surfacecolor)\n"
1102 "{\n"
1103 "       vec3 EyeVectorModelSpace = EyeVectorModelSpaceFogPlaneVertexDist.xyz;\n"
1104 "       float FogPlaneVertexDist = EyeVectorModelSpaceFogPlaneVertexDist.w;\n"
1105 "       float fogfrac;\n"
1106 "#ifdef USEFOGHEIGHTTEXTURE\n"
1107 "       vec4 fogheightpixel = texture2D(Texture_FogHeightTexture, vec2(1,1) + vec2(FogPlaneVertexDist, FogPlaneViewDist) * (-2.0 * FogHeightFade));\n"
1108 "       fogfrac = fogheightpixel.a;\n"
1109 "       return mix(fogheightpixel.rgb * FogColor, surfacecolor, texture2D(Texture_FogMask, myhalf2(length(EyeVectorModelSpace)*fogfrac*FogRangeRecip, 0.0)).r);\n"
1110 "#else\n"
1111 "# ifdef USEFOGOUTSIDE\n"
1112 "       fogfrac = min(0.0, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0, min(0.0, FogPlaneVertexDist) * FogHeightFade);\n"
1113 "# else\n"
1114 "       fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0, FogPlaneVertexDist)) * min(1.0, (min(0.0, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);\n"
1115 "# endif\n"
1116 "       return mix(FogColor, surfacecolor, texture2D(Texture_FogMask, myhalf2(length(EyeVectorModelSpace)*fogfrac*FogRangeRecip, 0.0)).r);\n"
1117 "#endif\n"
1118 "}\n"
1119 "#endif\n"
1120 "\n"
1121 "#ifdef USEOFFSETMAPPING\n"
1122 "uniform float OffsetMapping_Scale;\n"
1123 "vec2 OffsetMapping(vec2 TexCoord)\n"
1124 "{\n"
1125 "#ifdef USEOFFSETMAPPING_RELIEFMAPPING\n"
1126 "       // 14 sample relief mapping: linear search and then binary search\n"
1127 "       // this basically steps forward a small amount repeatedly until it finds\n"
1128 "       // itself inside solid, then jitters forward and back using decreasing\n"
1129 "       // amounts to find the impact\n"
1130 "       //vec3 OffsetVector = vec3(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1), -1);\n"
1131 "       //vec3 OffsetVector = vec3(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
1132 "       vec3 OffsetVector = vec3(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
1133 "       vec3 RT = vec3(TexCoord, 1);\n"
1134 "       OffsetVector *= 0.1;\n"
1135 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1136 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1137 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1138 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1139 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1140 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1141 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1142 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1143 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1144 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z)          - 0.5);\n"
1145 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.5    - 0.25);\n"
1146 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.25   - 0.125);\n"
1147 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.125  - 0.0625);\n"
1148 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.0625 - 0.03125);\n"
1149 "       return RT.xy;\n"
1150 "#else\n"
1151 "       // 3 sample offset mapping (only 3 samples because of ATI Radeon 9500-9800/X300 limits)\n"
1152 "       // this basically moves forward the full distance, and then backs up based\n"
1153 "       // on height of samples\n"
1154 "       //vec2 OffsetVector = vec2(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1));\n"
1155 "       //vec2 OffsetVector = vec2(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1));\n"
1156 "       vec2 OffsetVector = vec2(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1));\n"
1157 "       TexCoord += OffsetVector;\n"
1158 "       OffsetVector *= 0.333;\n"
1159 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
1160 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
1161 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
1162 "       return TexCoord;\n"
1163 "#endif\n"
1164 "}\n"
1165 "#endif // USEOFFSETMAPPING\n"
1166 "\n"
1167 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE)\n"
1168 "uniform sampler2D Texture_Attenuation;\n"
1169 "uniform samplerCube Texture_Cube;\n"
1170 "#endif\n"
1171 "\n"
1172 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USESHADOWMAPORTHO)\n"
1173 "\n"
1174 "#ifdef USESHADOWMAP2D\n"
1175 "# ifdef USESHADOWSAMPLER\n"
1176 "uniform sampler2DShadow Texture_ShadowMap2D;\n"
1177 "# else\n"
1178 "uniform sampler2D Texture_ShadowMap2D;\n"
1179 "# endif\n"
1180 "#endif\n"
1181 "\n"
1182 "#ifdef USESHADOWMAPVSDCT\n"
1183 "uniform samplerCube Texture_CubeProjection;\n"
1184 "#endif\n"
1185 "\n"
1186 "#if defined(USESHADOWMAP2D)\n"
1187 "uniform vec2 ShadowMap_TextureScale;\n"
1188 "uniform vec4 ShadowMap_Parameters;\n"
1189 "#endif\n"
1190 "\n"
1191 "#if defined(USESHADOWMAP2D)\n"
1192 "# ifdef USESHADOWMAPORTHO\n"
1193 "#  define GetShadowMapTC2D(dir) (min(dir, ShadowMap_Parameters.xyz))\n"
1194 "# else\n"
1195 "#  ifdef USESHADOWMAPVSDCT\n"
1196 "vec3 GetShadowMapTC2D(vec3 dir)\n"
1197 "{\n"
1198 "       vec3 adir = abs(dir);\n"
1199 "       vec2 aparams = ShadowMap_Parameters.xy / max(max(adir.x, adir.y), adir.z);\n"
1200 "       vec4 proj = textureCube(Texture_CubeProjection, dir);\n"
1201 "       return vec3(mix(dir.xy, dir.zz, proj.xy) * aparams.x + proj.zw * ShadowMap_Parameters.z, aparams.y + ShadowMap_Parameters.w);\n"
1202 "}\n"
1203 "#  else\n"
1204 "vec3 GetShadowMapTC2D(vec3 dir)\n"
1205 "{\n"
1206 "       vec3 adir = abs(dir);\n"
1207 "       float ma = adir.z;\n"
1208 "       vec4 proj = vec4(dir, 2.5);\n"
1209 "       if (adir.x > ma) { ma = adir.x; proj = vec4(dir.zyx, 0.5); }\n"
1210 "       if (adir.y > ma) { ma = adir.y; proj = vec4(dir.xzy, 1.5); }\n"
1211 "       vec2 aparams = ShadowMap_Parameters.xy / ma;\n"
1212 "       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"
1213 "}\n"
1214 "#  endif\n"
1215 "# endif\n"
1216 "#endif // defined(USESHADOWMAP2D)\n"
1217 "\n"
1218 "# ifdef USESHADOWMAP2D\n"
1219 "float ShadowMapCompare(vec3 dir)\n"
1220 "{\n"
1221 "       vec3 shadowmaptc = GetShadowMapTC2D(dir);\n"
1222 "       float f;\n"
1223 "\n"
1224 "#  ifdef USESHADOWSAMPLER\n"
1225 "#    ifdef USESHADOWMAPPCF\n"
1226 "#      define texval(x, y) shadow2D(Texture_ShadowMap2D, vec3(center + vec2(x, y)*ShadowMap_TextureScale, shadowmaptc.z)).r  \n"
1227 "       vec2 center = shadowmaptc.xy*ShadowMap_TextureScale;\n"
1228 "       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"
1229 "#    else\n"
1230 "       f = shadow2D(Texture_ShadowMap2D, vec3(shadowmaptc.xy*ShadowMap_TextureScale, shadowmaptc.z)).r;\n"
1231 "#    endif\n"
1232 "#  else\n"
1233 "#    ifdef USESHADOWMAPPCF\n"
1234 "#     if defined(GL_ARB_texture_gather) || defined(GL_AMD_texture_texture4)\n"
1235 "#      ifdef GL_ARB_texture_gather\n"
1236 "#        define texval(x, y) textureGatherOffset(Texture_ShadowMap2D, center, ivec2(x, y))\n"
1237 "#      else\n"
1238 "#        define texval(x, y) texture4(Texture_ShadowMap2D, center + vec2(x, y)*ShadowMap_TextureScale)\n"
1239 "#      endif\n"
1240 "       vec2 offset = fract(shadowmaptc.xy - 0.5), center = (shadowmaptc.xy - offset)*ShadowMap_TextureScale;\n"
1241 "#      if USESHADOWMAPPCF > 1\n"
1242 "   vec4 group1 = step(shadowmaptc.z, texval(-2.0, -2.0));\n"
1243 "   vec4 group2 = step(shadowmaptc.z, texval( 0.0, -2.0));\n"
1244 "   vec4 group3 = step(shadowmaptc.z, texval( 2.0, -2.0));\n"
1245 "   vec4 group4 = step(shadowmaptc.z, texval(-2.0,  0.0));\n"
1246 "   vec4 group5 = step(shadowmaptc.z, texval( 0.0,  0.0));\n"
1247 "   vec4 group6 = step(shadowmaptc.z, texval( 2.0,  0.0));\n"
1248 "   vec4 group7 = step(shadowmaptc.z, texval(-2.0,  2.0));\n"
1249 "   vec4 group8 = step(shadowmaptc.z, texval( 0.0,  2.0));\n"
1250 "   vec4 group9 = step(shadowmaptc.z, texval( 2.0,  2.0));\n"
1251 "       vec4 locols = vec4(group1.ab, group3.ab);\n"
1252 "       vec4 hicols = vec4(group7.rg, group9.rg);\n"
1253 "       locols.yz += group2.ab;\n"
1254 "       hicols.yz += group8.rg;\n"
1255 "       vec4 midcols = vec4(group1.rg, group3.rg) + vec4(group7.ab, group9.ab) +\n"
1256 "                               vec4(group4.rg, group6.rg) + vec4(group4.ab, group6.ab) +\n"
1257 "                               mix(locols, hicols, offset.y);\n"
1258 "       vec4 cols = group5 + vec4(group2.rg, group8.ab);\n"
1259 "       cols.xyz += mix(midcols.xyz, midcols.yzw, offset.x);\n"
1260 "       f = dot(cols, vec4(1.0/25.0));\n"
1261 "#      else\n"
1262 "       vec4 group1 = step(shadowmaptc.z, texval(-1.0, -1.0));\n"
1263 "       vec4 group2 = step(shadowmaptc.z, texval( 1.0, -1.0));\n"
1264 "       vec4 group3 = step(shadowmaptc.z, texval(-1.0,  1.0));\n"
1265 "       vec4 group4 = step(shadowmaptc.z, texval( 1.0,  1.0));\n"
1266 "       vec4 cols = vec4(group1.rg, group2.rg) + vec4(group3.ab, group4.ab) +\n"
1267 "                               mix(vec4(group1.ab, group2.ab), vec4(group3.rg, group4.rg), offset.y);\n"
1268 "       f = dot(mix(cols.xyz, cols.yzw, offset.x), vec3(1.0/9.0));\n"
1269 "#      endif\n"
1270 "#     else\n"
1271 "#      ifdef GL_EXT_gpu_shader4\n"
1272 "#        define texval(x, y) texture2DOffset(Texture_ShadowMap2D, center, ivec2(x, y)).r\n"
1273 "#      else\n"
1274 "#        define texval(x, y) texture2D(Texture_ShadowMap2D, center + vec2(x, y)*ShadowMap_TextureScale).r  \n"
1275 "#      endif\n"
1276 "#      if USESHADOWMAPPCF > 1\n"
1277 "       vec2 center = shadowmaptc.xy - 0.5, offset = fract(center);\n"
1278 "       center *= ShadowMap_TextureScale;\n"
1279 "       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"
1280 "       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"
1281 "       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"
1282 "       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"
1283 "       vec4 cols = row2 + row3 + mix(row1, row4, offset.y);\n"
1284 "       f = dot(mix(cols.xyz, cols.yzw, offset.x), vec3(1.0/9.0));\n"
1285 "#      else\n"
1286 "       vec2 center = shadowmaptc.xy*ShadowMap_TextureScale, offset = fract(shadowmaptc.xy);\n"
1287 "       vec3 row1 = step(shadowmaptc.z, vec3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n"
1288 "       vec3 row2 = step(shadowmaptc.z, vec3(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0)));\n"
1289 "       vec3 row3 = step(shadowmaptc.z, vec3(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0)));\n"
1290 "       vec3 cols = row2 + mix(row1, row3, offset.y);\n"
1291 "       f = dot(mix(cols.xy, cols.yz, offset.x), vec2(0.25));\n"
1292 "#      endif\n"
1293 "#     endif\n"
1294 "#    else\n"
1295 "       f = step(shadowmaptc.z, texture2D(Texture_ShadowMap2D, shadowmaptc.xy*ShadowMap_TextureScale).r);\n"
1296 "#    endif\n"
1297 "#  endif\n"
1298 "#  ifdef USESHADOWMAPORTHO\n"
1299 "       return mix(ShadowMap_Parameters.w, 1.0, f);\n"
1300 "#  else\n"
1301 "       return f;\n"
1302 "#  endif\n"
1303 "}\n"
1304 "# endif\n"
1305 "#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE) && !defined(USESHADOWMAPORTHO)\n"
1306 "#endif // FRAGMENT_SHADER\n"
1307 "\n"
1308 "\n"
1309 "\n"
1310 "\n"
1311 "#ifdef MODE_DEFERREDGEOMETRY\n"
1312 "#ifdef VERTEX_SHADER\n"
1313 "uniform mat4 TexMatrix;\n"
1314 "#ifdef USEVERTEXTEXTUREBLEND\n"
1315 "uniform mat4 BackgroundTexMatrix;\n"
1316 "#endif\n"
1317 "uniform mat4 ModelViewMatrix;\n"
1318 "void main(void)\n"
1319 "{\n"
1320 "       TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
1321 "#ifdef USEVERTEXTEXTUREBLEND\n"
1322 "       gl_FrontColor = gl_Color;\n"
1323 "       TexCoord2 = vec2(BackgroundTexMatrix * gl_MultiTexCoord0);\n"
1324 "#endif\n"
1325 "\n"
1326 "       // transform unnormalized eye direction into tangent space\n"
1327 "#ifdef USEOFFSETMAPPING\n"
1328 "       vec3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
1329 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
1330 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
1331 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
1332 "#endif\n"
1333 "\n"
1334 "       VectorS = (ModelViewMatrix * vec4(gl_MultiTexCoord1.xyz, 0)).xyz;\n"
1335 "       VectorT = (ModelViewMatrix * vec4(gl_MultiTexCoord2.xyz, 0)).xyz;\n"
1336 "       VectorR = (ModelViewMatrix * vec4(gl_MultiTexCoord3.xyz, 0)).xyz;\n"
1337 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
1338 "}\n"
1339 "#endif // VERTEX_SHADER\n"
1340 "\n"
1341 "#ifdef FRAGMENT_SHADER\n"
1342 "void main(void)\n"
1343 "{\n"
1344 "#ifdef USEOFFSETMAPPING\n"
1345 "       // apply offsetmapping\n"
1346 "       vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
1347 "#define TexCoord TexCoordOffset\n"
1348 "#endif\n"
1349 "\n"
1350 "#ifdef USEALPHAKILL\n"
1351 "       if (texture2D(Texture_Color, TexCoord).a < 0.5)\n"
1352 "               discard;\n"
1353 "#endif\n"
1354 "\n"
1355 "#ifdef USEVERTEXTEXTUREBLEND\n"
1356 "       float alpha = texture2D(Texture_Color, TexCoord).a;\n"
1357 "       float terrainblend = clamp(float(gl_Color.a) * alpha * 2.0 - 0.5, float(0.0), float(1.0));\n"
1358 "       //float terrainblend = min(float(gl_Color.a) * alpha * 2.0, float(1.0));\n"
1359 "       //float terrainblend = float(gl_Color.a) * alpha > 0.5;\n"
1360 "#endif\n"
1361 "\n"
1362 "#ifdef USEVERTEXTEXTUREBLEND\n"
1363 "       vec3 surfacenormal = mix(vec3(texture2D(Texture_SecondaryNormal, TexCoord2)), vec3(texture2D(Texture_Normal, TexCoord)), terrainblend) - vec3(0.5, 0.5, 0.5);\n"
1364 "       float a = mix(texture2D(Texture_SecondaryGloss, TexCoord2).a, texture2D(Texture_Gloss, TexCoord).a, terrainblend);\n"
1365 "#else\n"
1366 "       vec3 surfacenormal = vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5, 0.5, 0.5);\n"
1367 "       float a = texture2D(Texture_Gloss, TexCoord).a;\n"
1368 "#endif\n"
1369 "\n"
1370 "       gl_FragColor = vec4(normalize(surfacenormal.x * VectorS + surfacenormal.y * VectorT + surfacenormal.z * VectorR) * 0.5 + vec3(0.5, 0.5, 0.5), a);\n"
1371 "}\n"
1372 "#endif // FRAGMENT_SHADER\n"
1373 "#else // !MODE_DEFERREDGEOMETRY\n"
1374 "\n"
1375 "\n"
1376 "\n"
1377 "\n"
1378 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
1379 "#ifdef VERTEX_SHADER\n"
1380 "uniform mat4 ModelViewMatrix;\n"
1381 "void main(void)\n"
1382 "{\n"
1383 "       ModelViewPosition = ModelViewMatrix * gl_Vertex;\n"
1384 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
1385 "}\n"
1386 "#endif // VERTEX_SHADER\n"
1387 "\n"
1388 "#ifdef FRAGMENT_SHADER\n"
1389 "uniform mat4 ViewToLight;\n"
1390 "// ScreenToDepth = vec2(Far / (Far - Near), Far * Near / (Near - Far));\n"
1391 "uniform vec2 ScreenToDepth;\n"
1392 "uniform myhalf3 DeferredColor_Ambient;\n"
1393 "uniform myhalf3 DeferredColor_Diffuse;\n"
1394 "#ifdef USESPECULAR\n"
1395 "uniform myhalf3 DeferredColor_Specular;\n"
1396 "uniform myhalf SpecularPower;\n"
1397 "#endif\n"
1398 "uniform myhalf2 PixelToScreenTexCoord;\n"
1399 "void main(void)\n"
1400 "{\n"
1401 "       // calculate viewspace pixel position\n"
1402 "       vec2 ScreenTexCoord = gl_FragCoord.xy * PixelToScreenTexCoord;\n"
1403 "       vec3 position;\n"
1404 "       position.z = ScreenToDepth.y / (texture2D(Texture_ScreenDepth, ScreenTexCoord).r + ScreenToDepth.x);\n"
1405 "       position.xy = ModelViewPosition.xy * (position.z / ModelViewPosition.z);\n"
1406 "       // decode viewspace pixel normal\n"
1407 "       myhalf4 normalmap = texture2D(Texture_ScreenNormalMap, ScreenTexCoord);\n"
1408 "       myhalf3 surfacenormal = normalize(normalmap.rgb - myhalf3(0.5,0.5,0.5));\n"
1409 "       // surfacenormal = pixel normal in viewspace\n"
1410 "       // LightVector = pixel to light in viewspace\n"
1411 "       // CubeVector = position in lightspace\n"
1412 "       // eyevector = pixel to view in viewspace\n"
1413 "       vec3 CubeVector = vec3(ViewToLight * vec4(position,1));\n"
1414 "       myhalf fade = myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n"
1415 "#ifdef USEDIFFUSE\n"
1416 "       // calculate diffuse shading\n"
1417 "       myhalf3 lightnormal = myhalf3(normalize(LightPosition - position));\n"
1418 "       myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
1419 "#endif\n"
1420 "#ifdef USESPECULAR\n"
1421 "       // calculate directional shading\n"
1422 "       vec3 eyevector = position * -1.0;\n"
1423 "#  ifdef USEEXACTSPECULARMATH\n"
1424 "       myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(eyevector)))*-1.0, 0.0)), SpecularPower * normalmap.a);\n"
1425 "#  else\n"
1426 "       myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(eyevector)));\n"
1427 "       myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * normalmap.a);\n"
1428 "#  endif\n"
1429 "#endif\n"
1430 "\n"
1431 "#if defined(USESHADOWMAP2D)\n"
1432 "       fade *= ShadowMapCompare(CubeVector);\n"
1433 "#endif\n"
1434 "\n"
1435 "#ifdef USEDIFFUSE\n"
1436 "       gl_FragData[0] = vec4((DeferredColor_Ambient + DeferredColor_Diffuse * diffuse) * fade, 1.0);\n"
1437 "#else\n"
1438 "       gl_FragData[0] = vec4(DeferredColor_Ambient * fade, 1.0);\n"
1439 "#endif\n"
1440 "#ifdef USESPECULAR\n"
1441 "       gl_FragData[1] = vec4(DeferredColor_Specular * (specular * fade), 1.0);\n"
1442 "#else\n"
1443 "       gl_FragData[1] = vec4(0.0, 0.0, 0.0, 1.0);\n"
1444 "#endif\n"
1445 "\n"
1446 "# ifdef USECUBEFILTER\n"
1447 "       vec3 cubecolor = textureCube(Texture_Cube, CubeVector).rgb;\n"
1448 "       gl_FragData[0].rgb *= cubecolor;\n"
1449 "       gl_FragData[1].rgb *= cubecolor;\n"
1450 "# endif\n"
1451 "}\n"
1452 "#endif // FRAGMENT_SHADER\n"
1453 "#else // !MODE_DEFERREDLIGHTSOURCE\n"
1454 "\n"
1455 "\n"
1456 "\n"
1457 "\n"
1458 "#ifdef VERTEX_SHADER\n"
1459 "uniform mat4 TexMatrix;\n"
1460 "#ifdef USEVERTEXTEXTUREBLEND\n"
1461 "uniform mat4 BackgroundTexMatrix;\n"
1462 "#endif\n"
1463 "#ifdef MODE_LIGHTSOURCE\n"
1464 "uniform mat4 ModelToLight;\n"
1465 "#endif\n"
1466 "#ifdef USESHADOWMAPORTHO\n"
1467 "uniform mat4 ShadowMapMatrix;\n"
1468 "#endif\n"
1469 "void main(void)\n"
1470 "{\n"
1471 "#if defined(MODE_VERTEXCOLOR) || defined(USEVERTEXTEXTUREBLEND)\n"
1472 "       gl_FrontColor = gl_Color;\n"
1473 "#endif\n"
1474 "       // copy the surface texcoord\n"
1475 "       TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
1476 "#ifdef USEVERTEXTEXTUREBLEND\n"
1477 "       TexCoord2 = vec2(BackgroundTexMatrix * gl_MultiTexCoord0);\n"
1478 "#endif\n"
1479 "#ifdef USELIGHTMAP\n"
1480 "       TexCoordLightmap = vec2(gl_MultiTexCoord4);\n"
1481 "#endif\n"
1482 "\n"
1483 "#ifdef MODE_LIGHTSOURCE\n"
1484 "       // transform vertex position into light attenuation/cubemap space\n"
1485 "       // (-1 to +1 across the light box)\n"
1486 "       CubeVector = vec3(ModelToLight * gl_Vertex);\n"
1487 "\n"
1488 "# ifdef USEDIFFUSE\n"
1489 "       // transform unnormalized light direction into tangent space\n"
1490 "       // (we use unnormalized to ensure that it interpolates correctly and then\n"
1491 "       //  normalize it per pixel)\n"
1492 "       vec3 lightminusvertex = LightPosition - gl_Vertex.xyz;\n"
1493 "       LightVector.x = dot(lightminusvertex, gl_MultiTexCoord1.xyz);\n"
1494 "       LightVector.y = dot(lightminusvertex, gl_MultiTexCoord2.xyz);\n"
1495 "       LightVector.z = dot(lightminusvertex, gl_MultiTexCoord3.xyz);\n"
1496 "# endif\n"
1497 "#endif\n"
1498 "\n"
1499 "#if defined(MODE_LIGHTDIRECTION) && defined(USEDIFFUSE)\n"
1500 "       LightVector.x = dot(LightDir, gl_MultiTexCoord1.xyz);\n"
1501 "       LightVector.y = dot(LightDir, gl_MultiTexCoord2.xyz);\n"
1502 "       LightVector.z = dot(LightDir, gl_MultiTexCoord3.xyz);\n"
1503 "#endif\n"
1504 "\n"
1505 "       // transform unnormalized eye direction into tangent space\n"
1506 "#ifdef USEEYEVECTOR\n"
1507 "       vec3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
1508 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
1509 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
1510 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
1511 "#endif\n"
1512 "\n"
1513 "#ifdef USEFOG\n"
1514 "       EyeVectorModelSpaceFogPlaneVertexDist.xyz = EyePosition - gl_Vertex.xyz;\n"
1515 "       EyeVectorModelSpaceFogPlaneVertexDist.w = dot(FogPlane, gl_Vertex);\n"
1516 "#endif\n"
1517 "\n"
1518 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(USEREFLECTCUBE)\n"
1519 "       VectorS = gl_MultiTexCoord1.xyz;\n"
1520 "       VectorT = gl_MultiTexCoord2.xyz;\n"
1521 "       VectorR = gl_MultiTexCoord3.xyz;\n"
1522 "#endif\n"
1523 "\n"
1524 "       // transform vertex to camera space, using ftransform to match non-VS rendering\n"
1525 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
1526 "\n"
1527 "#ifdef USESHADOWMAPORTHO\n"
1528 "       ShadowMapTC = vec3(ShadowMapMatrix * gl_Position);\n"
1529 "#endif\n"
1530 "\n"
1531 "#ifdef USEREFLECTION\n"
1532 "       ModelViewProjectionPosition = gl_Position;\n"
1533 "#endif\n"
1534 "}\n"
1535 "#endif // VERTEX_SHADER\n"
1536 "\n"
1537 "\n"
1538 "\n"
1539 "\n"
1540 "#ifdef FRAGMENT_SHADER\n"
1541 "#ifdef USEDEFERREDLIGHTMAP\n"
1542 "uniform myhalf2 PixelToScreenTexCoord;\n"
1543 "uniform myhalf3 DeferredMod_Diffuse;\n"
1544 "uniform myhalf3 DeferredMod_Specular;\n"
1545 "#endif\n"
1546 "uniform myhalf3 Color_Ambient;\n"
1547 "uniform myhalf3 Color_Diffuse;\n"
1548 "uniform myhalf3 Color_Specular;\n"
1549 "uniform myhalf SpecularPower;\n"
1550 "#ifdef USEGLOW\n"
1551 "uniform myhalf3 Color_Glow;\n"
1552 "#endif\n"
1553 "uniform myhalf Alpha;\n"
1554 "#ifdef USEREFLECTION\n"
1555 "uniform vec4 DistortScaleRefractReflect;\n"
1556 "uniform vec4 ScreenScaleRefractReflect;\n"
1557 "uniform vec4 ScreenCenterRefractReflect;\n"
1558 "uniform myhalf4 ReflectColor;\n"
1559 "#endif\n"
1560 "#ifdef USEREFLECTCUBE\n"
1561 "uniform mat4 ModelToReflectCube;\n"
1562 "uniform sampler2D Texture_ReflectMask;\n"
1563 "uniform samplerCube Texture_ReflectCube;\n"
1564 "#endif\n"
1565 "#ifdef MODE_LIGHTDIRECTION\n"
1566 "uniform myhalf3 LightColor;\n"
1567 "#endif\n"
1568 "#ifdef MODE_LIGHTSOURCE\n"
1569 "uniform myhalf3 LightColor;\n"
1570 "#endif\n"
1571 "void main(void)\n"
1572 "{\n"
1573 "#ifdef USEOFFSETMAPPING\n"
1574 "       // apply offsetmapping\n"
1575 "       vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
1576 "#define TexCoord TexCoordOffset\n"
1577 "#endif\n"
1578 "\n"
1579 "       // combine the diffuse textures (base, pants, shirt)\n"
1580 "       myhalf4 color = myhalf4(texture2D(Texture_Color, TexCoord));\n"
1581 "#ifdef USEALPHAKILL\n"
1582 "       if (color.a < 0.5)\n"
1583 "               discard;\n"
1584 "#endif\n"
1585 "       color.a *= Alpha;\n"
1586 "#ifdef USECOLORMAPPING\n"
1587 "       color.rgb += myhalf3(texture2D(Texture_Pants, TexCoord)) * Color_Pants + myhalf3(texture2D(Texture_Shirt, TexCoord)) * Color_Shirt;\n"
1588 "#endif\n"
1589 "#ifdef USEVERTEXTEXTUREBLEND\n"
1590 "       myhalf terrainblend = clamp(myhalf(gl_Color.a) * color.a * 2.0 - 0.5, myhalf(0.0), myhalf(1.0));\n"
1591 "       //myhalf terrainblend = min(myhalf(gl_Color.a) * color.a * 2.0, myhalf(1.0));\n"
1592 "       //myhalf terrainblend = myhalf(gl_Color.a) * color.a > 0.5;\n"
1593 "       color.rgb = mix(myhalf3(texture2D(Texture_SecondaryColor, TexCoord2)), color.rgb, terrainblend);\n"
1594 "       color.a = 1.0;\n"
1595 "       //color = mix(myhalf4(1, 0, 0, 1), color, terrainblend);\n"
1596 "#endif\n"
1597 "\n"
1598 "       // get the surface normal\n"
1599 "#ifdef USEVERTEXTEXTUREBLEND\n"
1600 "       myhalf3 surfacenormal = normalize(mix(myhalf3(texture2D(Texture_SecondaryNormal, TexCoord2)), myhalf3(texture2D(Texture_Normal, TexCoord)), terrainblend) - myhalf3(0.5, 0.5, 0.5));\n"
1601 "#else\n"
1602 "       myhalf3 surfacenormal = normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5, 0.5, 0.5));\n"
1603 "#endif\n"
1604 "\n"
1605 "       // get the material colors\n"
1606 "       myhalf3 diffusetex = color.rgb;\n"
1607 "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
1608 "# ifdef USEVERTEXTEXTUREBLEND\n"
1609 "       myhalf4 glosstex = mix(myhalf4(texture2D(Texture_SecondaryGloss, TexCoord2)), myhalf4(texture2D(Texture_Gloss, TexCoord)), terrainblend);\n"
1610 "# else\n"
1611 "       myhalf4 glosstex = myhalf4(texture2D(Texture_Gloss, TexCoord));\n"
1612 "# endif\n"
1613 "#endif\n"
1614 "\n"
1615 "#ifdef USEREFLECTCUBE\n"
1616 "       vec3 TangentReflectVector = reflect(-EyeVector, surfacenormal);\n"
1617 "       vec3 ModelReflectVector = TangentReflectVector.x * VectorS + TangentReflectVector.y * VectorT + TangentReflectVector.z * VectorR;\n"
1618 "       vec3 ReflectCubeTexCoord = vec3(ModelToReflectCube * vec4(ModelReflectVector, 0));\n"
1619 "       diffusetex += myhalf3(texture2D(Texture_ReflectMask, TexCoord)) * myhalf3(textureCube(Texture_ReflectCube, ReflectCubeTexCoord));\n"
1620 "#endif\n"
1621 "\n"
1622 "\n"
1623 "\n"
1624 "\n"
1625 "#ifdef MODE_LIGHTSOURCE\n"
1626 "       // light source\n"
1627 "#ifdef USEDIFFUSE\n"
1628 "       myhalf3 lightnormal = myhalf3(normalize(LightVector));\n"
1629 "       myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
1630 "       color.rgb = diffusetex * (Color_Ambient + diffuse * Color_Diffuse);\n"
1631 "#ifdef USESPECULAR\n"
1632 "#ifdef USEEXACTSPECULARMATH\n"
1633 "       myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a);\n"
1634 "#else\n"
1635 "       myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(EyeVector)));\n"
1636 "       myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a);\n"
1637 "#endif\n"
1638 "       color.rgb += glosstex.rgb * (specular * Color_Specular);\n"
1639 "#endif\n"
1640 "#else\n"
1641 "       color.rgb = diffusetex * Color_Ambient;\n"
1642 "#endif\n"
1643 "       color.rgb *= LightColor;\n"
1644 "       color.rgb *= myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n"
1645 "#if defined(USESHADOWMAP2D)\n"
1646 "       color.rgb *= ShadowMapCompare(CubeVector);\n"
1647 "#endif\n"
1648 "# ifdef USECUBEFILTER\n"
1649 "       color.rgb *= myhalf3(textureCube(Texture_Cube, CubeVector));\n"
1650 "# endif\n"
1651 "#endif // MODE_LIGHTSOURCE\n"
1652 "\n"
1653 "\n"
1654 "\n"
1655 "\n"
1656 "#ifdef MODE_LIGHTDIRECTION\n"
1657 "#define SHADING\n"
1658 "#ifdef USEDIFFUSE\n"
1659 "       myhalf3 lightnormal = myhalf3(normalize(LightVector));\n"
1660 "#endif\n"
1661 "#define lightcolor LightColor\n"
1662 "#endif // MODE_LIGHTDIRECTION\n"
1663 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
1664 "#define SHADING\n"
1665 "       // deluxemap lightmapping using light vectors in modelspace (q3map2 -light -deluxe)\n"
1666 "       myhalf3 lightnormal_modelspace = myhalf3(texture2D(Texture_Deluxemap, TexCoordLightmap)) * 2.0 + myhalf3(-1.0, -1.0, -1.0);\n"
1667 "       myhalf3 lightcolor = myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap));\n"
1668 "       // convert modelspace light vector to tangentspace\n"
1669 "       myhalf3 lightnormal;\n"
1670 "       lightnormal.x = dot(lightnormal_modelspace, myhalf3(VectorS));\n"
1671 "       lightnormal.y = dot(lightnormal_modelspace, myhalf3(VectorT));\n"
1672 "       lightnormal.z = dot(lightnormal_modelspace, myhalf3(VectorR));\n"
1673 "       // calculate directional shading (and undoing the existing angle attenuation on the lightmap by the division)\n"
1674 "       // note that q3map2 is too stupid to calculate proper surface normals when q3map_nonplanar\n"
1675 "       // is used (the lightmap and deluxemap coords correspond to virtually random coordinates\n"
1676 "       // on that luxel, and NOT to its center, because recursive triangle subdivision is used\n"
1677 "       // to map the luxels to coordinates on the draw surfaces), which also causes\n"
1678 "       // deluxemaps to be wrong because light contributions from the wrong side of the surface\n"
1679 "       // are added up. To prevent divisions by zero or strong exaggerations, a max()\n"
1680 "       // nudge is done here at expense of some additional fps. This is ONLY needed for\n"
1681 "       // deluxemaps, tangentspace deluxemap avoid this problem by design.\n"
1682 "       lightcolor *= 1.0 / max(0.25, lightnormal.z);\n"
1683 "#endif // MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
1684 "#ifdef MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
1685 "#define SHADING\n"
1686 "       // deluxemap lightmapping using light vectors in tangentspace (hmap2 -light)\n"
1687 "       myhalf3 lightnormal = myhalf3(texture2D(Texture_Deluxemap, TexCoordLightmap)) * 2.0 + myhalf3(-1.0, -1.0, -1.0);\n"
1688 "       myhalf3 lightcolor = myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap));\n"
1689 "#endif\n"
1690 "\n"
1691 "\n"
1692 "\n"
1693 "\n"
1694 "#ifdef MODE_FAKELIGHT\n"
1695 "#define SHADING\n"
1696 "myhalf3 lightnormal = myhalf3(normalize(EyeVector));\n"
1697 "myhalf3 lightcolor = myhalf3(1.0);\n"
1698 "#endif // MODE_FAKELIGHT\n"
1699 "\n"
1700 "\n"
1701 "\n"
1702 "\n"
1703 "#ifdef MODE_LIGHTMAP\n"
1704 "       color.rgb = diffusetex * (Color_Ambient + myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap)) * Color_Diffuse);\n"
1705 "#endif // MODE_LIGHTMAP\n"
1706 "#ifdef MODE_VERTEXCOLOR\n"
1707 "       color.rgb = diffusetex * (Color_Ambient + myhalf3(gl_Color.rgb) * Color_Diffuse);\n"
1708 "#endif // MODE_VERTEXCOLOR\n"
1709 "#ifdef MODE_FLATCOLOR\n"
1710 "       color.rgb = diffusetex * Color_Ambient;\n"
1711 "#endif // MODE_FLATCOLOR\n"
1712 "\n"
1713 "\n"
1714 "\n"
1715 "\n"
1716 "#ifdef SHADING\n"
1717 "# ifdef USEDIFFUSE\n"
1718 "       myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
1719 "#  ifdef USESPECULAR\n"
1720 "#   ifdef USEEXACTSPECULARMATH\n"
1721 "       myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a);\n"
1722 "#   else\n"
1723 "       myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(EyeVector)));\n"
1724 "       myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a);\n"
1725 "#   endif\n"
1726 "       color.rgb = diffusetex * Color_Ambient + (diffusetex * Color_Diffuse * diffuse + glosstex.rgb * Color_Specular * specular) * lightcolor;\n"
1727 "#  else\n"
1728 "       color.rgb = diffusetex * (Color_Ambient + Color_Diffuse * diffuse * lightcolor);\n"
1729 "#  endif\n"
1730 "# else\n"
1731 "       color.rgb = diffusetex * Color_Ambient;\n"
1732 "# endif\n"
1733 "#endif\n"
1734 "\n"
1735 "#ifdef USESHADOWMAPORTHO\n"
1736 "       color.rgb *= ShadowMapCompare(ShadowMapTC);\n"
1737 "#endif\n"
1738 "\n"
1739 "#ifdef USEDEFERREDLIGHTMAP\n"
1740 "       vec2 ScreenTexCoord = gl_FragCoord.xy * PixelToScreenTexCoord;\n"
1741 "       color.rgb += diffusetex * myhalf3(texture2D(Texture_ScreenDiffuse, ScreenTexCoord)) * DeferredMod_Diffuse;\n"
1742 "       color.rgb += glosstex.rgb * myhalf3(texture2D(Texture_ScreenSpecular, ScreenTexCoord)) * DeferredMod_Specular;\n"
1743 "#endif\n"
1744 "\n"
1745 "#ifdef USEGLOW\n"
1746 "#ifdef USEVERTEXTEXTUREBLEND\n"
1747 "       color.rgb += mix(myhalf3(texture2D(Texture_SecondaryGlow, TexCoord2)), myhalf3(texture2D(Texture_Glow, TexCoord)), terrainblend) * Color_Glow;\n"
1748 "#else\n"
1749 "       color.rgb += myhalf3(texture2D(Texture_Glow, TexCoord)) * Color_Glow;\n"
1750 "#endif\n"
1751 "#endif\n"
1752 "\n"
1753 "#ifdef USEFOG\n"
1754 "       color.rgb = FogVertex(color.rgb);\n"
1755 "#endif\n"
1756 "\n"
1757 "       // 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"
1758 "#ifdef USEREFLECTION\n"
1759 "       vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
1760 "       //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
1761 "       vec2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW.zw + ScreenCenterRefractReflect.zw;\n"
1762 "       vec2 ScreenTexCoord = SafeScreenTexCoord + vec3(normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5))).xy * DistortScaleRefractReflect.zw;\n"
1763 "       // FIXME temporary hack to detect the case that the reflection\n"
1764 "       // gets blackened at edges due to leaving the area that contains actual\n"
1765 "       // content.\n"
1766 "       // Remove this 'ack once we have a better way to stop this thing from\n"
1767 "       // 'appening.\n"
1768 "       float f = min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(0.01, 0.01)).rgb) / 0.05);\n"
1769 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(0.01, -0.01)).rgb) / 0.05);\n"
1770 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
1771 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
1772 "       ScreenTexCoord = mix(SafeScreenTexCoord, ScreenTexCoord, f);\n"
1773 "       color.rgb = mix(color.rgb, myhalf3(texture2D(Texture_Reflection, ScreenTexCoord)) * ReflectColor.rgb, ReflectColor.a);\n"
1774 "#endif\n"
1775 "\n"
1776 "       gl_FragColor = vec4(color);\n"
1777 "}\n"
1778 "#endif // FRAGMENT_SHADER\n"
1779 "\n"
1780 "#endif // !MODE_DEFERREDLIGHTSOURCE\n"
1781 "#endif // !MODE_DEFERREDGEOMETRY\n"
1782 "#endif // !MODE_WATER\n"
1783 "#endif // !MODE_REFRACTION\n"
1784 "#endif // !MODE_BLOOMBLUR\n"
1785 "#endif // !MODE_GENERIC\n"
1786 "#endif // !MODE_POSTPROCESS\n"
1787 "#endif // !MODE_SHOWDEPTH\n"
1788 "#endif // !MODE_DEPTH_OR_SHADOW\n"
1789 ;
1790
1791 /*
1792 =========================================================================================================================================================
1793
1794
1795
1796 =========================================================================================================================================================
1797
1798
1799
1800 =========================================================================================================================================================
1801
1802
1803
1804 =========================================================================================================================================================
1805
1806
1807
1808 =========================================================================================================================================================
1809
1810
1811
1812 =========================================================================================================================================================
1813
1814
1815
1816 =========================================================================================================================================================
1817 */
1818
1819 const char *builtincgshaderstring =
1820 "// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
1821 "// written by Forest 'LordHavoc' Hale\n"
1822 "// shadowmapping enhancements by Lee 'eihrul' Salzman\n"
1823 "\n"
1824 "// FIXME: we need to get rid of ModelViewProjectionPosition to make room for the texcoord for this\n"
1825 "#if defined(USEREFLECTION)\n"
1826 "#undef USESHADOWMAPORTHO\n"
1827 "#endif\n"
1828 "\n"
1829 "#if defined(USEFOGINSIDE) || defined(USEFOGOUTSIDE) || defined(USEFOGHEIGHTTEXTURE)\n"
1830 "# define USEFOG\n"
1831 "#endif\n"
1832 "#if defined(MODE_LIGHTMAP) || defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
1833 "#define USELIGHTMAP\n"
1834 "#endif\n"
1835 "#if defined(USESPECULAR) || defined(USEOFFSETMAPPING) || defined(USEREFLECTCUBE) || defined(MODE_FAKELIGHT)\n"
1836 "#define USEEYEVECTOR\n"
1837 "#endif\n"
1838 "\n"
1839 "#ifdef FRAGMENT_SHADER\n"
1840 "#ifdef HLSL\n"
1841 "//#undef USESHADOWMAPPCF\n"
1842 "//#define texDepth2D(tex,texcoord) tex2D(tex,texcoord).r\n"
1843 "#define texDepth2D(tex,texcoord) dot(tex2D(tex,texcoord).rgb, float3(1.0, 255.0/65536.0, 255.0/16777216.0))\n"
1844 "#else\n"
1845 "#define texDepth2D(tex,texcoord) tex2D(tex,texcoord).r\n"
1846 "#endif\n"
1847 "#endif\n"
1848 "\n"
1849 "#ifdef MODE_DEPTH_OR_SHADOW\n"
1850 "#ifdef VERTEX_SHADER\n"
1851 "void main\n"
1852 "(\n"
1853 "float4 gl_Vertex : POSITION,\n"
1854 "uniform float4x4 ModelViewProjectionMatrix : register(c8),\n"
1855 "out float4 gl_Position : POSITION,\n"
1856 "out float Depth : TEXCOORD0\n"
1857 ")\n"
1858 "{\n"
1859 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
1860 "       Depth = gl_Position.z;\n"
1861 "}\n"
1862 "#endif\n"
1863 "\n"
1864 "#ifdef FRAGMENT_SHADER\n"
1865 "void main\n"
1866 "(\n"
1867 "float Depth : TEXCOORD0,\n"
1868 "out float4 gl_FragColor : COLOR\n"
1869 ")\n"
1870 "{\n"
1871 "//     float3 temp = float3(Depth,Depth*(65536.0/255.0),Depth*(16777216.0/255.0));\n"
1872 "       float4 temp = float4(Depth,Depth*256.0,Depth*65536.0,0.0);\n"
1873 "       temp.yz -= floor(temp.yz);\n"
1874 "       gl_FragColor = temp;\n"
1875 "//     gl_FragColor = float4(Depth,0,0,0);\n"
1876 "}\n"
1877 "#endif\n"
1878 "#else // !MODE_DEPTH_ORSHADOW\n"
1879 "\n"
1880 "\n"
1881 "\n"
1882 "\n"
1883 "#ifdef MODE_SHOWDEPTH\n"
1884 "#ifdef VERTEX_SHADER\n"
1885 "void main\n"
1886 "(\n"
1887 "float4 gl_Vertex : POSITION,\n"
1888 "uniform float4x4 ModelViewProjectionMatrix : register(c8),\n"
1889 "out float4 gl_Position : POSITION,\n"
1890 "out float4 gl_FrontColor : COLOR0\n"
1891 ")\n"
1892 "{\n"
1893 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
1894 "       gl_FrontColor = float4(gl_Position.z, gl_Position.z, gl_Position.z, 1.0);\n"
1895 "}\n"
1896 "#endif\n"
1897 "\n"
1898 "#ifdef FRAGMENT_SHADER\n"
1899 "void main\n"
1900 "(\n"
1901 "float4 gl_FrontColor : COLOR0,\n"
1902 "out float4 gl_FragColor : COLOR\n"
1903 ")\n"
1904 "{\n"
1905 "       gl_FragColor = gl_FrontColor;\n"
1906 "}\n"
1907 "#endif\n"
1908 "#else // !MODE_SHOWDEPTH\n"
1909 "\n"
1910 "\n"
1911 "\n"
1912 "\n"
1913 "#ifdef MODE_POSTPROCESS\n"
1914 "\n"
1915 "#ifdef VERTEX_SHADER\n"
1916 "void main\n"
1917 "(\n"
1918 "float4 gl_Vertex : POSITION,\n"
1919 "uniform float4x4 ModelViewProjectionMatrix : register(c8),\n"
1920 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
1921 "float4 gl_MultiTexCoord4 : TEXCOORD4,\n"
1922 "out float4 gl_Position : POSITION,\n"
1923 "out float2 TexCoord1 : TEXCOORD0,\n"
1924 "out float2 TexCoord2 : TEXCOORD1\n"
1925 ")\n"
1926 "{\n"
1927 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
1928 "       TexCoord1 = gl_MultiTexCoord0.xy;\n"
1929 "#ifdef USEBLOOM\n"
1930 "       TexCoord2 = gl_MultiTexCoord4.xy;\n"
1931 "#endif\n"
1932 "}\n"
1933 "#endif\n"
1934 "\n"
1935 "#ifdef FRAGMENT_SHADER\n"
1936 "void main\n"
1937 "(\n"
1938 "float2 TexCoord1 : TEXCOORD0,\n"
1939 "float2 TexCoord2 : TEXCOORD1,\n"
1940 "uniform sampler Texture_First : register(s0),\n"
1941 "#ifdef USEBLOOM\n"
1942 "uniform sampler Texture_Second : register(s1),\n"
1943 "#endif\n"
1944 "#ifdef USEGAMMARAMPS\n"
1945 "uniform sampler Texture_GammaRamps : register(s2),\n"
1946 "#endif\n"
1947 "#ifdef USESATURATION\n"
1948 "uniform float Saturation : register(c30),\n"
1949 "#endif\n"
1950 "#ifdef USEVIEWTINT\n"
1951 "uniform float4 ViewTintColor : register(c41),\n"
1952 "#endif\n"
1953 "uniform float4 UserVec1 : register(c37),\n"
1954 "uniform float4 UserVec2 : register(c38),\n"
1955 "uniform float4 UserVec3 : register(c39),\n"
1956 "uniform float4 UserVec4 : register(c40),\n"
1957 "uniform float ClientTime : register(c2),\n"
1958 "uniform float2 PixelSize : register(c25),\n"
1959 "uniform float4 BloomColorSubtract : register(c43),\n"
1960 "out float4 gl_FragColor : COLOR\n"
1961 ")\n"
1962 "{\n"
1963 "       gl_FragColor = tex2D(Texture_First, TexCoord1);\n"
1964 "#ifdef USEBLOOM\n"
1965 "       gl_FragColor += max(float4(0,0,0,0), tex2D(Texture_Second, TexCoord2) - BloomColorSubtract);\n"
1966 "#endif\n"
1967 "#ifdef USEVIEWTINT\n"
1968 "       gl_FragColor = lerp(gl_FragColor, ViewTintColor, ViewTintColor.a);\n"
1969 "#endif\n"
1970 "\n"
1971 "#ifdef USEPOSTPROCESSING\n"
1972 "// do r_glsl_dumpshader, edit glsl/default.glsl, and replace this by your own postprocessing if you want\n"
1973 "// 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"
1974 "       float sobel = 1.0;\n"
1975 "       // float2 ts = textureSize(Texture_First, 0);\n"
1976 "       // float2 px = float2(1/ts.x, 1/ts.y);\n"
1977 "       float2 px = PixelSize;\n"
1978 "       float3 x1 = tex2D(Texture_First, TexCoord1 + float2(-px.x, px.y)).rgb;\n"
1979 "       float3 x2 = tex2D(Texture_First, TexCoord1 + float2(-px.x,  0.0)).rgb;\n"
1980 "       float3 x3 = tex2D(Texture_First, TexCoord1 + float2(-px.x,-px.y)).rgb;\n"
1981 "       float3 x4 = tex2D(Texture_First, TexCoord1 + float2( px.x, px.y)).rgb;\n"
1982 "       float3 x5 = tex2D(Texture_First, TexCoord1 + float2( px.x,  0.0)).rgb;\n"
1983 "       float3 x6 = tex2D(Texture_First, TexCoord1 + float2( px.x,-px.y)).rgb;\n"
1984 "       float3 y1 = tex2D(Texture_First, TexCoord1 + float2( px.x,-px.y)).rgb;\n"
1985 "       float3 y2 = tex2D(Texture_First, TexCoord1 + float2(  0.0,-px.y)).rgb;\n"
1986 "       float3 y3 = tex2D(Texture_First, TexCoord1 + float2(-px.x,-px.y)).rgb;\n"
1987 "       float3 y4 = tex2D(Texture_First, TexCoord1 + float2( px.x, px.y)).rgb;\n"
1988 "       float3 y5 = tex2D(Texture_First, TexCoord1 + float2(  0.0, px.y)).rgb;\n"
1989 "       float3 y6 = tex2D(Texture_First, TexCoord1 + float2(-px.x, px.y)).rgb;\n"
1990 "       float px1 = -1.0 * dot(float3(0.3, 0.59, 0.11), x1);\n"
1991 "       float px2 = -2.0 * dot(float3(0.3, 0.59, 0.11), x2);\n"
1992 "       float px3 = -1.0 * dot(float3(0.3, 0.59, 0.11), x3);\n"
1993 "       float px4 =  1.0 * dot(float3(0.3, 0.59, 0.11), x4);\n"
1994 "       float px5 =  2.0 * dot(float3(0.3, 0.59, 0.11), x5);\n"
1995 "       float px6 =  1.0 * dot(float3(0.3, 0.59, 0.11), x6);\n"
1996 "       float py1 = -1.0 * dot(float3(0.3, 0.59, 0.11), y1);\n"
1997 "       float py2 = -2.0 * dot(float3(0.3, 0.59, 0.11), y2);\n"
1998 "       float py3 = -1.0 * dot(float3(0.3, 0.59, 0.11), y3);\n"
1999 "       float py4 =  1.0 * dot(float3(0.3, 0.59, 0.11), y4);\n"
2000 "       float py5 =  2.0 * dot(float3(0.3, 0.59, 0.11), y5);\n"
2001 "       float py6 =  1.0 * dot(float3(0.3, 0.59, 0.11), y6);\n"
2002 "       sobel = 0.25 * abs(px1 + px2 + px3 + px4 + px5 + px6) + 0.25 * abs(py1 + py2 + py3 + py4 + py5 + py6);\n"
2003 "       gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2(-0.987688, -0.156434)) * UserVec1.y;\n"
2004 "       gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2(-0.156434, -0.891007)) * UserVec1.y;\n"
2005 "       gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2( 0.891007, -0.453990)) * UserVec1.y;\n"
2006 "       gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2( 0.707107,  0.707107)) * UserVec1.y;\n"
2007 "       gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2(-0.453990,  0.891007)) * UserVec1.y;\n"
2008 "       gl_FragColor /= (1.0 + 5.0 * UserVec1.y);\n"
2009 "       gl_FragColor.rgb = gl_FragColor.rgb * (1.0 + UserVec2.x) + float3(1,1,1)*max(0.0, sobel - UserVec2.z)*UserVec2.y;\n"
2010 "#endif\n"
2011 "\n"
2012 "#ifdef USESATURATION\n"
2013 "       //apply saturation BEFORE gamma ramps, so v_glslgamma value does not matter\n"
2014 "       float y = dot(gl_FragColor.rgb, float3(0.299, 0.587, 0.114));\n"
2015 "       // 'vampire sight' effect, wheres red is compensated\n"
2016 "       #ifdef SATURATION_REDCOMPENSATE\n"
2017 "               float rboost = max(0.0, (gl_FragColor.r - max(gl_FragColor.g, gl_FragColor.b))*(1.0 - Saturation));\n"
2018 "               gl_FragColor.rgb = mix(float3(y,y,y), gl_FragColor.rgb, Saturation);\n"
2019 "               gl_FragColor.r += r;\n"
2020 "       #else\n"
2021 "               // normal desaturation\n"
2022 "               //gl_FragColor = float3(y,y,y) + (gl_FragColor.rgb - float3(y)) * Saturation;\n"
2023 "               gl_FragColor.rgb = lerp(float3(y,y,y), gl_FragColor.rgb, Saturation);\n"
2024 "       #endif\n"
2025 "#endif\n"
2026 "\n"
2027 "#ifdef USEGAMMARAMPS\n"
2028 "       gl_FragColor.r = tex2D(Texture_GammaRamps, float2(gl_FragColor.r, 0)).r;\n"
2029 "       gl_FragColor.g = tex2D(Texture_GammaRamps, float2(gl_FragColor.g, 0)).g;\n"
2030 "       gl_FragColor.b = tex2D(Texture_GammaRamps, float2(gl_FragColor.b, 0)).b;\n"
2031 "#endif\n"
2032 "}\n"
2033 "#endif\n"
2034 "#else // !MODE_POSTPROCESS\n"
2035 "\n"
2036 "\n"
2037 "\n"
2038 "\n"
2039 "#ifdef MODE_GENERIC\n"
2040 "#ifdef VERTEX_SHADER\n"
2041 "void main\n"
2042 "(\n"
2043 "float4 gl_Vertex : POSITION,\n"
2044 "uniform float4x4 ModelViewProjectionMatrix : register(c8),\n"
2045 "float4 gl_Color : COLOR0,\n"
2046 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2047 "float4 gl_MultiTexCoord1 : TEXCOORD1,\n"
2048 "out float4 gl_Position : POSITION,\n"
2049 "#ifdef USEDIFFUSE\n"
2050 "out float2 TexCoord1 : TEXCOORD0,\n"
2051 "#endif\n"
2052 "#ifdef USESPECULAR\n"
2053 "out float2 TexCoord2 : TEXCOORD1,\n"
2054 "#endif\n"
2055 "out float4 gl_FrontColor : COLOR\n"
2056 ")\n"
2057 "{\n"
2058 "#ifdef HLSL\n"
2059 "       gl_FrontColor = gl_Color.bgra; // NOTE: D3DCOLOR is backwards\n"
2060 "#else\n"
2061 "       gl_FrontColor = gl_Color; // Cg is forward\n"
2062 "#endif\n"
2063 "#ifdef USEDIFFUSE\n"
2064 "       TexCoord1 = gl_MultiTexCoord0.xy;\n"
2065 "#endif\n"
2066 "#ifdef USESPECULAR\n"
2067 "       TexCoord2 = gl_MultiTexCoord1.xy;\n"
2068 "#endif\n"
2069 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2070 "}\n"
2071 "#endif\n"
2072 "\n"
2073 "#ifdef FRAGMENT_SHADER\n"
2074 "\n"
2075 "void main\n"
2076 "(\n"
2077 "float4 gl_FrontColor : COLOR0,\n"
2078 "float2 TexCoord1 : TEXCOORD0,\n"
2079 "float2 TexCoord2 : TEXCOORD1,\n"
2080 "#ifdef USEDIFFUSE\n"
2081 "uniform sampler Texture_First : register(s0),\n"
2082 "#endif\n"
2083 "#ifdef USESPECULAR\n"
2084 "uniform sampler Texture_Second : register(s1),\n"
2085 "#endif\n"
2086 "out float4 gl_FragColor : COLOR\n"
2087 ")\n"
2088 "{\n"
2089 "       gl_FragColor = gl_FrontColor;\n"
2090 "#ifdef USEDIFFUSE\n"
2091 "       gl_FragColor *= tex2D(Texture_First, TexCoord1);\n"
2092 "#endif\n"
2093 "\n"
2094 "#ifdef USESPECULAR\n"
2095 "       float4 tex2 = tex2D(Texture_Second, TexCoord2);\n"
2096 "# ifdef USECOLORMAPPING\n"
2097 "       gl_FragColor *= tex2;\n"
2098 "# endif\n"
2099 "# ifdef USEGLOW\n"
2100 "       gl_FragColor += tex2;\n"
2101 "# endif\n"
2102 "# ifdef USEVERTEXTEXTUREBLEND\n"
2103 "       gl_FragColor = lerp(gl_FragColor, tex2, tex2.a);\n"
2104 "# endif\n"
2105 "#endif\n"
2106 "}\n"
2107 "#endif\n"
2108 "#else // !MODE_GENERIC\n"
2109 "\n"
2110 "\n"
2111 "\n"
2112 "\n"
2113 "#ifdef MODE_BLOOMBLUR\n"
2114 "#ifdef VERTEX_SHADER\n"
2115 "void main\n"
2116 "(\n"
2117 "float4 gl_Vertex : POSITION,\n"
2118 "uniform float4x4 ModelViewProjectionMatrix : register(c8),\n"
2119 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2120 "out float4 gl_Position : POSITION,\n"
2121 "out float2 TexCoord : TEXCOORD0\n"
2122 ")\n"
2123 "{\n"
2124 "       TexCoord = gl_MultiTexCoord0.xy;\n"
2125 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2126 "}\n"
2127 "#endif\n"
2128 "\n"
2129 "#ifdef FRAGMENT_SHADER\n"
2130 "\n"
2131 "void main\n"
2132 "(\n"
2133 "float2 TexCoord : TEXCOORD0,\n"
2134 "uniform sampler Texture_First : register(s0),\n"
2135 "uniform float4 BloomBlur_Parameters : register(c1),\n"
2136 "out float4 gl_FragColor : COLOR\n"
2137 ")\n"
2138 "{\n"
2139 "       int i;\n"
2140 "       float2 tc = TexCoord;\n"
2141 "       float3 color = tex2D(Texture_First, tc).rgb;\n"
2142 "       tc += BloomBlur_Parameters.xy;\n"
2143 "       for (i = 1;i < SAMPLES;i++)\n"
2144 "       {\n"
2145 "               color += tex2D(Texture_First, tc).rgb;\n"
2146 "               tc += BloomBlur_Parameters.xy;\n"
2147 "       }\n"
2148 "       gl_FragColor = float4(color * BloomBlur_Parameters.z + float3(BloomBlur_Parameters.w), 1);\n"
2149 "}\n"
2150 "#endif\n"
2151 "#else // !MODE_BLOOMBLUR\n"
2152 "#ifdef MODE_REFRACTION\n"
2153 "#ifdef VERTEX_SHADER\n"
2154 "void main\n"
2155 "(\n"
2156 "float4 gl_Vertex : POSITION,\n"
2157 "uniform float4x4 ModelViewProjectionMatrix : register(c8),\n"
2158 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2159 "uniform float4x4 TexMatrix : register(c0),\n"
2160 "uniform float3 EyePosition : register(c24),\n"
2161 "out float4 gl_Position : POSITION,\n"
2162 "out float2 TexCoord : TEXCOORD0,\n"
2163 "out float3 EyeVector : TEXCOORD1,\n"
2164 "out float4 ModelViewProjectionPosition : TEXCOORD2\n"
2165 ")\n"
2166 "{\n"
2167 "       TexCoord = mul(TexMatrix, gl_MultiTexCoord0).xy;\n"
2168 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2169 "       ModelViewProjectionPosition = gl_Position;\n"
2170 "}\n"
2171 "#endif\n"
2172 "\n"
2173 "#ifdef FRAGMENT_SHADER\n"
2174 "void main\n"
2175 "(\n"
2176 "float2 TexCoord : TEXCOORD0,\n"
2177 "float3 EyeVector : TEXCOORD1,\n"
2178 "float4 ModelViewProjectionPosition : TEXCOORD2,\n"
2179 "uniform sampler Texture_Normal : register(s0),\n"
2180 "uniform sampler Texture_Refraction : register(s3),\n"
2181 "uniform sampler Texture_Reflection : register(s7),\n"
2182 "uniform float4 DistortScaleRefractReflect : register(c14),\n"
2183 "uniform float4 ScreenScaleRefractReflect : register(c32),\n"
2184 "uniform float4 ScreenCenterRefractReflect : register(c31),\n"
2185 "uniform float4 RefractColor : register(c29),\n"
2186 "out float4 gl_FragColor : COLOR\n"
2187 ")\n"
2188 "{\n"
2189 "       float2 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect.xy * (1.0 / ModelViewProjectionPosition.w);\n"
2190 "       //float2 ScreenTexCoord = (ModelViewProjectionPosition.xy + normalize(tex2D(Texture_Normal, TexCoord).rgb - float3(0.5,0.5,0.5)).xy * DistortScaleRefractReflect.xy * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
2191 "       float2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
2192 "       float2 ScreenTexCoord = SafeScreenTexCoord + float2(normalize(tex2D(Texture_Normal, TexCoord).rgb - float3(0.5,0.5,0.5))).xy * DistortScaleRefractReflect.xy;\n"
2193 "       // FIXME temporary hack to detect the case that the reflection\n"
2194 "       // gets blackened at edges due to leaving the area that contains actual\n"
2195 "       // content.\n"
2196 "       // Remove this 'ack once we have a better way to stop this thing from\n"
2197 "       // 'appening.\n"
2198 "       float f = min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord + float2(0.01, 0.01)).rgb) / 0.05);\n"
2199 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord + float2(0.01, -0.01)).rgb) / 0.05);\n"
2200 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord + float2(-0.01, 0.01)).rgb) / 0.05);\n"
2201 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord + float2(-0.01, -0.01)).rgb) / 0.05);\n"
2202 "       ScreenTexCoord = lerp(SafeScreenTexCoord, ScreenTexCoord, f);\n"
2203 "       gl_FragColor = float4(tex2D(Texture_Refraction, ScreenTexCoord).rgb, 1) * RefractColor;\n"
2204 "}\n"
2205 "#endif\n"
2206 "#else // !MODE_REFRACTION\n"
2207 "\n"
2208 "\n"
2209 "\n"
2210 "\n"
2211 "#ifdef MODE_WATER\n"
2212 "#ifdef VERTEX_SHADER\n"
2213 "\n"
2214 "void main\n"
2215 "(\n"
2216 "float4 gl_Vertex : POSITION,\n"
2217 "uniform float4x4 ModelViewProjectionMatrix : register(c8),\n"
2218 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2219 "float4 gl_MultiTexCoord1 : TEXCOORD1,\n"
2220 "float4 gl_MultiTexCoord2 : TEXCOORD2,\n"
2221 "float4 gl_MultiTexCoord3 : TEXCOORD3,\n"
2222 "uniform float4x4 TexMatrix : register(c0),\n"
2223 "uniform float3 EyePosition : register(c24),\n"
2224 "out float4 gl_Position : POSITION,\n"
2225 "out float2 TexCoord : TEXCOORD0,\n"
2226 "out float3 EyeVector : TEXCOORD1,\n"
2227 "out float4 ModelViewProjectionPosition : TEXCOORD2\n"
2228 ")\n"
2229 "{\n"
2230 "       TexCoord = mul(TexMatrix, gl_MultiTexCoord0).xy;\n"
2231 "       float3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
2232 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
2233 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
2234 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
2235 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2236 "       ModelViewProjectionPosition = gl_Position;\n"
2237 "}\n"
2238 "#endif\n"
2239 "\n"
2240 "#ifdef FRAGMENT_SHADER\n"
2241 "void main\n"
2242 "(\n"
2243 "float2 TexCoord : TEXCOORD0,\n"
2244 "float3 EyeVector : TEXCOORD1,\n"
2245 "float4 ModelViewProjectionPosition : TEXCOORD2,\n"
2246 "uniform sampler Texture_Normal : register(s0),\n"
2247 "uniform sampler Texture_Refraction : register(s3),\n"
2248 "uniform sampler Texture_Reflection : register(s7),\n"
2249 "uniform float4 DistortScaleRefractReflect : register(c14),\n"
2250 "uniform float4 ScreenScaleRefractReflect : register(c32),\n"
2251 "uniform float4 ScreenCenterRefractReflect : register(c31),\n"
2252 "uniform float4 RefractColor : register(c29),\n"
2253 "uniform float4 ReflectColor : register(c26),\n"
2254 "uniform float ReflectFactor : register(c27),\n"
2255 "uniform float ReflectOffset : register(c28),\n"
2256 "out float4 gl_FragColor : COLOR\n"
2257 ")\n"
2258 "{\n"
2259 "       float4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
2260 "       //float4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(tex2D(Texture_Normal, TexCoord).rgb - float3(0.5,0.5,0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
2261 "       float4 SafeScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
2262 "       //SafeScreenTexCoord = gl_FragCoord.xyxy * float4(1.0 / 1920.0, 1.0 / 1200.0, 1.0 / 1920.0, 1.0 / 1200.0);\n"
2263 "       float4 ScreenTexCoord = SafeScreenTexCoord + float2(normalize(tex2D(Texture_Normal, TexCoord).rgb - float3(0.5,0.5,0.5)).xy).xyxy * DistortScaleRefractReflect;\n"
2264 "       // FIXME temporary hack to detect the case that the reflection\n"
2265 "       // gets blackened at edges due to leaving the area that contains actual\n"
2266 "       // content.\n"
2267 "       // Remove this 'ack once we have a better way to stop this thing from\n"
2268 "       // 'appening.\n"
2269 "       float f = min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord.xy + float2(0.01, 0.01)).rgb) / 0.05);\n"
2270 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord.xy + float2(0.01, -0.01)).rgb) / 0.05);\n"
2271 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord.xy + float2(-0.01, 0.01)).rgb) / 0.05);\n"
2272 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord.xy + float2(-0.01, -0.01)).rgb) / 0.05);\n"
2273 "       ScreenTexCoord.xy = lerp(SafeScreenTexCoord.xy, ScreenTexCoord.xy, f);\n"
2274 "       f       = min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord.zw + float2(0.01, 0.01)).rgb) / 0.05);\n"
2275 "       f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord.zw + float2(0.01, -0.01)).rgb) / 0.05);\n"
2276 "       f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord.zw + float2(-0.01, 0.01)).rgb) / 0.05);\n"
2277 "       f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord.zw + float2(-0.01, -0.01)).rgb) / 0.05);\n"
2278 "       ScreenTexCoord.zw = lerp(SafeScreenTexCoord.zw, ScreenTexCoord.zw, f);\n"
2279 "       float Fresnel = pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 2.0) * ReflectFactor + ReflectOffset;\n"
2280 "       gl_FragColor = lerp(float4(tex2D(Texture_Refraction, ScreenTexCoord.xy).rgb, 1) * RefractColor, float4(tex2D(Texture_Reflection, ScreenTexCoord.zw).rgb, 1) * ReflectColor, Fresnel);\n"
2281 "}\n"
2282 "#endif\n"
2283 "#else // !MODE_WATER\n"
2284 "\n"
2285 "\n"
2286 "\n"
2287 "\n"
2288 "// 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"
2289 "\n"
2290 "// fragment shader specific:\n"
2291 "#ifdef FRAGMENT_SHADER\n"
2292 "\n"
2293 "#ifdef USEFOG\n"
2294 "float3 FogVertex(float3 surfacecolor, float3 FogColor, float3 EyeVectorModelSpace, float FogPlaneVertexDist, float FogRangeRecip, float FogPlaneViewDist, float FogHeightFade, sampler Texture_FogMask, sampler Texture_FogHeightTexture)\n"
2295 "{\n"
2296 "       float fogfrac;\n"
2297 "#ifdef USEFOGHEIGHTTEXTURE\n"
2298 "       float4 fogheightpixel = tex2D(Texture_FogHeightTexture, float2(1,1) + float2(FogPlaneVertexDist, FogPlaneViewDist) * (-2.0 * FogHeightFade));\n"
2299 "       fogfrac = fogheightpixel.a;\n"
2300 "       return lerp(fogheightpixel.rgb * FogColor, surfacecolor, tex2D(Texture_FogMask, float2(length(EyeVectorModelSpace)*fogfrac*FogRangeRecip, 0.0)).r);\n"
2301 "#else\n"
2302 "# ifdef USEFOGOUTSIDE\n"
2303 "       fogfrac = min(0.0, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0, min(0.0, FogPlaneVertexDist) * FogHeightFade);\n"
2304 "# else\n"
2305 "       fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0, FogPlaneVertexDist)) * min(1.0, (min(0.0, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);\n"
2306 "# endif\n"
2307 "       return lerp(FogColor, surfacecolor, tex2D(Texture_FogMask, float2(length(EyeVectorModelSpace)*fogfrac*FogRangeRecip, 0.0)).r);\n"
2308 "#endif\n"
2309 "}\n"
2310 "#endif\n"
2311 "\n"
2312 "#ifdef USEOFFSETMAPPING\n"
2313 "float2 OffsetMapping(float2 TexCoord, float OffsetMapping_Scale, float3 EyeVector, sampler Texture_Normal)\n"
2314 "{\n"
2315 "#ifdef USEOFFSETMAPPING_RELIEFMAPPING\n"
2316 "       // 14 sample relief mapping: linear search and then binary search\n"
2317 "       // this basically steps forward a small amount repeatedly until it finds\n"
2318 "       // itself inside solid, then jitters forward and back using decreasing\n"
2319 "       // amounts to find the impact\n"
2320 "       //float3 OffsetVector = float3(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * float2(-1, 1), -1);\n"
2321 "       //float3 OffsetVector = float3(normalize(EyeVector.xy) * OffsetMapping_Scale * float2(-1, 1), -1);\n"
2322 "       float3 OffsetVector = float3(normalize(EyeVector).xy * OffsetMapping_Scale * float2(-1, 1), -1);\n"
2323 "       float3 RT = float3(TexCoord, 1);\n"
2324 "       OffsetVector *= 0.1;\n"
2325 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2326 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2327 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2328 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2329 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2330 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2331 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2332 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2333 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2334 "       RT += OffsetVector * (step(tex2D(Texture_Normal, RT.xy).a, RT.z)          - 0.5);\n"
2335 "       RT += OffsetVector * (step(tex2D(Texture_Normal, RT.xy).a, RT.z) * 0.5    - 0.25);\n"
2336 "       RT += OffsetVector * (step(tex2D(Texture_Normal, RT.xy).a, RT.z) * 0.25   - 0.125);\n"
2337 "       RT += OffsetVector * (step(tex2D(Texture_Normal, RT.xy).a, RT.z) * 0.125  - 0.0625);\n"
2338 "       RT += OffsetVector * (step(tex2D(Texture_Normal, RT.xy).a, RT.z) * 0.0625 - 0.03125);\n"
2339 "       return RT.xy;\n"
2340 "#else\n"
2341 "       // 3 sample offset mapping (only 3 samples because of ATI Radeon 9500-9800/X300 limits)\n"
2342 "       // this basically moves forward the full distance, and then backs up based\n"
2343 "       // on height of samples\n"
2344 "       //float2 OffsetVector = float2(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * float2(-1, 1));\n"
2345 "       //float2 OffsetVector = float2(normalize(EyeVector.xy) * OffsetMapping_Scale * float2(-1, 1));\n"
2346 "       float2 OffsetVector = float2(normalize(EyeVector).xy * OffsetMapping_Scale * float2(-1, 1));\n"
2347 "       TexCoord += OffsetVector;\n"
2348 "       OffsetVector *= 0.333;\n"
2349 "       TexCoord -= OffsetVector * tex2D(Texture_Normal, TexCoord).a;\n"
2350 "       TexCoord -= OffsetVector * tex2D(Texture_Normal, TexCoord).a;\n"
2351 "       TexCoord -= OffsetVector * tex2D(Texture_Normal, TexCoord).a;\n"
2352 "       return TexCoord;\n"
2353 "#endif\n"
2354 "}\n"
2355 "#endif // USEOFFSETMAPPING\n"
2356 "\n"
2357 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USESHADOWMAPORTHO)\n"
2358 "#if defined(USESHADOWMAP2D)\n"
2359 "# ifdef USESHADOWMAPORTHO\n"
2360 "#  define GetShadowMapTC2D(dir, ShadowMap_Parameters) (min(dir, ShadowMap_Parameters.xyz))\n"
2361 "# else\n"
2362 "#  ifdef USESHADOWMAPVSDCT\n"
2363 "float3 GetShadowMapTC2D(float3 dir, float4 ShadowMap_Parameters, samplerCUBE Texture_CubeProjection)\n"
2364 "{\n"
2365 "       float3 adir = abs(dir);\n"
2366 "       float2 aparams = ShadowMap_Parameters.xy / max(max(adir.x, adir.y), adir.z);\n"
2367 "       float4 proj = texCUBE(Texture_CubeProjection, dir);\n"
2368 "       return float3(lerp(dir.xy, dir.zz, proj.xy) * aparams.x + proj.zw * ShadowMap_Parameters.z, aparams.y + ShadowMap_Parameters.w);\n"
2369 "}\n"
2370 "#  else\n"
2371 "float3 GetShadowMapTC2D(float3 dir, float4 ShadowMap_Parameters)\n"
2372 "{\n"
2373 "       float3 adir = abs(dir);\n"
2374 "       float ma = adir.z;\n"
2375 "       float4 proj = float4(dir, 2.5);\n"
2376 "       if (adir.x > ma) { ma = adir.x; proj = float4(dir.zyx, 0.5); }\n"
2377 "       if (adir.y > ma) { ma = adir.y; proj = float4(dir.xzy, 1.5); }\n"
2378 "#ifdef HLSL\n"
2379 "       return float3(proj.xy * ShadowMap_Parameters.x / ma + float2(0.5,0.5) + float2(proj.z < 0.0 ? 1.5 : 0.5, proj.w) * ShadowMap_Parameters.z, ma + 64 * ShadowMap_Parameters.w);\n"
2380 "#else\n"
2381 "       float2 aparams = ShadowMap_Parameters.xy / ma;\n"
2382 "       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"
2383 "#endif\n"
2384 "}\n"
2385 "#  endif\n"
2386 "# endif\n"
2387 "#endif // defined(USESHADOWMAP2D)\n"
2388 "\n"
2389 "# ifdef USESHADOWMAP2D\n"
2390 "#ifdef USESHADOWMAPVSDCT\n"
2391 "float ShadowMapCompare(float3 dir, sampler Texture_ShadowMap2D, float4 ShadowMap_Parameters, float2 ShadowMap_TextureScale, samplerCUBE Texture_CubeProjection)\n"
2392 "#else\n"
2393 "float ShadowMapCompare(float3 dir, sampler Texture_ShadowMap2D, float4 ShadowMap_Parameters, float2 ShadowMap_TextureScale)\n"
2394 "#endif\n"
2395 "{\n"
2396 "#ifdef USESHADOWMAPVSDCT\n"
2397 "       float3 shadowmaptc = GetShadowMapTC2D(dir, ShadowMap_Parameters, Texture_CubeProjection);\n"
2398 "#else\n"
2399 "       float3 shadowmaptc = GetShadowMapTC2D(dir, ShadowMap_Parameters);\n"
2400 "#endif\n"
2401 "       float f;\n"
2402 "\n"
2403 "#  ifdef USESHADOWSAMPLER\n"
2404 "#    ifdef USESHADOWMAPPCF\n"
2405 "#      define texval(x, y) tex2Dproj(Texture_ShadowMap2D, float4(center + float2(x, y)*ShadowMap_TextureScale, shadowmaptc.z, 1.0)).r  \n"
2406 "       float2 center = shadowmaptc.xy*ShadowMap_TextureScale;\n"
2407 "       f = dot(float4(0.25,0.25,0.25,0.25), float4(texval(-0.4, 1.0), texval(-1.0, -0.4), texval(0.4, -1.0), texval(1.0, 0.4)));\n"
2408 "#    else\n"
2409 "       f = tex2Dproj(Texture_ShadowMap2D, float4(shadowmaptc.xy*ShadowMap_TextureScale, shadowmaptc.z, 1.0)).r;\n"
2410 "#    endif\n"
2411 "#  else\n"
2412 "#    ifdef USESHADOWMAPPCF\n"
2413 "#     if defined(GL_ARB_texture_gather) || defined(GL_AMD_texture_texture4)\n"
2414 "#      ifdef GL_ARB_texture_gather\n"
2415 "#        define texval(x, y) textureGatherOffset(Texture_ShadowMap2D, center, int2(x, y))\n"
2416 "#      else\n"
2417 "#        define texval(x, y) texture4(Texture_ShadowMap2D, center + float2(x, y)*ShadowMap_TextureScale)\n"
2418 "#      endif\n"
2419 "       float2 offset = frac(shadowmaptc.xy - 0.5), center = (shadowmaptc.xy - offset)*ShadowMap_TextureScale;\n"
2420 "#      if USESHADOWMAPPCF > 1\n"
2421 "       float4 group1 = step(shadowmaptc.z, texval(-2.0, -2.0));\n"
2422 "       float4 group2 = step(shadowmaptc.z, texval( 0.0, -2.0));\n"
2423 "       float4 group3 = step(shadowmaptc.z, texval( 2.0, -2.0));\n"
2424 "       float4 group4 = step(shadowmaptc.z, texval(-2.0,  0.0));\n"
2425 "       float4 group5 = step(shadowmaptc.z, texval( 0.0,  0.0));\n"
2426 "       float4 group6 = step(shadowmaptc.z, texval( 2.0,  0.0));\n"
2427 "       float4 group7 = step(shadowmaptc.z, texval(-2.0,  2.0));\n"
2428 "       float4 group8 = step(shadowmaptc.z, texval( 0.0,  2.0));\n"
2429 "       float4 group9 = step(shadowmaptc.z, texval( 2.0,  2.0));\n"
2430 "       float4 locols = float4(group1.ab, group3.ab);\n"
2431 "       float4 hicols = float4(group7.rg, group9.rg);\n"
2432 "       locols.yz += group2.ab;\n"
2433 "       hicols.yz += group8.rg;\n"
2434 "       float4 midcols = float4(group1.rg, group3.rg) + float4(group7.ab, group9.ab) +\n"
2435 "                               float4(group4.rg, group6.rg) + float4(group4.ab, group6.ab) +\n"
2436 "                               lerp(locols, hicols, offset.y);\n"
2437 "       float4 cols = group5 + float4(group2.rg, group8.ab);\n"
2438 "       cols.xyz += lerp(midcols.xyz, midcols.yzw, offset.x);\n"
2439 "       f = dot(cols, float4(1.0/25.0));\n"
2440 "#      else\n"
2441 "       float4 group1 = step(shadowmaptc.z, texval(-1.0, -1.0));\n"
2442 "       float4 group2 = step(shadowmaptc.z, texval( 1.0, -1.0));\n"
2443 "       float4 group3 = step(shadowmaptc.z, texval(-1.0,  1.0));\n"
2444 "       float4 group4 = step(shadowmaptc.z, texval( 1.0,  1.0));\n"
2445 "       float4 cols = float4(group1.rg, group2.rg) + float4(group3.ab, group4.ab) +\n"
2446 "                               lerp(float4(group1.ab, group2.ab), float4(group3.rg, group4.rg), offset.y);\n"
2447 "       f = dot(lerp(cols.xyz, cols.yzw, offset.x), float3(1.0/9.0));\n"
2448 "#      endif\n"
2449 "#     else\n"
2450 "#      ifdef GL_EXT_gpu_shader4\n"
2451 "#        define texval(x, y) tex2DOffset(Texture_ShadowMap2D, center, int2(x, y)).r\n"
2452 "#      else\n"
2453 "#        define texval(x, y) texDepth2D(Texture_ShadowMap2D, center + float2(x, y)*ShadowMap_TextureScale).r  \n"
2454 "#      endif\n"
2455 "#      if USESHADOWMAPPCF > 1\n"
2456 "       float2 center = shadowmaptc.xy - 0.5, offset = frac(center);\n"
2457 "       center *= ShadowMap_TextureScale;\n"
2458 "       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"
2459 "       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"
2460 "       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"
2461 "       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"
2462 "       float4 cols = row2 + row3 + lerp(row1, row4, offset.y);\n"
2463 "       f = dot(lerp(cols.xyz, cols.yzw, offset.x), float3(1.0/9.0));\n"
2464 "#      else\n"
2465 "       float2 center = shadowmaptc.xy*ShadowMap_TextureScale, offset = frac(shadowmaptc.xy);\n"
2466 "       float3 row1 = step(shadowmaptc.z, float3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n"
2467 "       float3 row2 = step(shadowmaptc.z, float3(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0)));\n"
2468 "       float3 row3 = step(shadowmaptc.z, float3(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0)));\n"
2469 "       float3 cols = row2 + lerp(row1, row3, offset.y);\n"
2470 "       f = dot(lerp(cols.xy, cols.yz, offset.x), float2(0.25,0.25));\n"
2471 "#      endif\n"
2472 "#     endif\n"
2473 "#    else\n"
2474 "       f = step(shadowmaptc.z, tex2D(Texture_ShadowMap2D, shadowmaptc.xy*ShadowMap_TextureScale).r);\n"
2475 "#    endif\n"
2476 "#  endif\n"
2477 "#  ifdef USESHADOWMAPORTHO\n"
2478 "       return lerp(ShadowMap_Parameters.w, 1.0, f);\n"
2479 "#  else\n"
2480 "       return f;\n"
2481 "#  endif\n"
2482 "}\n"
2483 "# endif\n"
2484 "#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE) && !defined(USESHADOWMAPORTHO)\n"
2485 "#endif // FRAGMENT_SHADER\n"
2486 "\n"
2487 "\n"
2488 "\n"
2489 "\n"
2490 "#ifdef MODE_DEFERREDGEOMETRY\n"
2491 "#ifdef VERTEX_SHADER\n"
2492 "void main\n"
2493 "(\n"
2494 "float4 gl_Vertex : POSITION,\n"
2495 "uniform float4x4 ModelViewProjectionMatrix : register(c8),\n"
2496 "#ifdef USEVERTEXTEXTUREBLEND\n"
2497 "float4 gl_Color : COLOR0,\n"
2498 "#endif\n"
2499 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2500 "float4 gl_MultiTexCoord1 : TEXCOORD1,\n"
2501 "float4 gl_MultiTexCoord2 : TEXCOORD2,\n"
2502 "float4 gl_MultiTexCoord3 : TEXCOORD3,\n"
2503 "uniform float4x4 TexMatrix : register(c0),\n"
2504 "#ifdef USEVERTEXTEXTUREBLEND\n"
2505 "uniform float4x4 BackgroundTexMatrix : register(c4),\n"
2506 "#endif\n"
2507 "uniform float4x4 ModelViewMatrix : register(c12),\n"
2508 "#ifdef USEOFFSETMAPPING\n"
2509 "uniform float3 EyePosition : register(c24),\n"
2510 "#endif\n"
2511 "out float4 gl_Position : POSITION,\n"
2512 "#ifdef USEVERTEXTEXTUREBLEND\n"
2513 "out float4 gl_FrontColor : COLOR,\n"
2514 "#endif\n"
2515 "out float4 TexCoordBoth : TEXCOORD0,\n"
2516 "#ifdef USEOFFSETMAPPING\n"
2517 "out float3 EyeVector : TEXCOORD2,\n"
2518 "#endif\n"
2519 "out float3 VectorS : TEXCOORD5, // direction of S texcoord (sometimes crudely called tangent)\n"
2520 "out float3 VectorT : TEXCOORD6, // direction of T texcoord (sometimes crudely called binormal)\n"
2521 "out float4 VectorR : TEXCOORD7 // direction of R texcoord (surface normal), Depth value\n"
2522 ")\n"
2523 "{\n"
2524 "       TexCoordBoth = mul(TexMatrix, gl_MultiTexCoord0);\n"
2525 "#ifdef USEVERTEXTEXTUREBLEND\n"
2526 "#ifdef HLSL\n"
2527 "       gl_FrontColor = gl_Color.bgra; // NOTE: D3DCOLOR is backwards\n"
2528 "#else\n"
2529 "       gl_FrontColor = gl_Color; // Cg is forward\n"
2530 "#endif\n"
2531 "       TexCoordBoth.zw = float2(Backgroundmul(TexMatrix, gl_MultiTexCoord0));\n"
2532 "#endif\n"
2533 "\n"
2534 "       // transform unnormalized eye direction into tangent space\n"
2535 "#ifdef USEOFFSETMAPPING\n"
2536 "       float3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
2537 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
2538 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
2539 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
2540 "#endif\n"
2541 "\n"
2542 "       VectorS = mul(ModelViewMatrix, float4(gl_MultiTexCoord1.xyz, 0)).xyz;\n"
2543 "       VectorT = mul(ModelViewMatrix, float4(gl_MultiTexCoord2.xyz, 0)).xyz;\n"
2544 "       VectorR.xyz = mul(ModelViewMatrix, float4(gl_MultiTexCoord3.xyz, 0)).xyz;\n"
2545 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2546 "       VectorR.w = gl_Position.z;\n"
2547 "}\n"
2548 "#endif // VERTEX_SHADER\n"
2549 "\n"
2550 "#ifdef FRAGMENT_SHADER\n"
2551 "void main\n"
2552 "(\n"
2553 "float4 TexCoordBoth : TEXCOORD0,\n"
2554 "float3 EyeVector : TEXCOORD2,\n"
2555 "float3 VectorS : TEXCOORD5, // direction of S texcoord (sometimes crudely called tangent)\n"
2556 "float3 VectorT : TEXCOORD6, // direction of T texcoord (sometimes crudely called binormal)\n"
2557 "float4 VectorR : TEXCOORD7, // direction of R texcoord (surface normal), Depth value\n"
2558 "uniform sampler Texture_Normal : register(s0),\n"
2559 "#ifdef USEALPHAKILL\n"
2560 "uniform sampler Texture_Color : register(s1),\n"
2561 "#endif\n"
2562 "uniform sampler Texture_Gloss : register(s2),\n"
2563 "#ifdef USEVERTEXTEXTUREBLEND\n"
2564 "uniform sampler Texture_SecondaryNormal : register(s4),\n"
2565 "uniform sampler Texture_SecondaryGloss : register(s6),\n"
2566 "#endif\n"
2567 "#ifdef USEOFFSETMAPPING\n"
2568 "uniform float OffsetMapping_Scale : register(c24),\n"
2569 "#endif\n"
2570 "uniform half SpecularPower : register(c36),\n"
2571 "#ifdef HLSL\n"
2572 "out float4 gl_FragData0 : COLOR0,\n"
2573 "out float4 gl_FragData1 : COLOR1\n"
2574 "#else\n"
2575 "out float4 gl_FragColor : COLOR\n"
2576 "#endif\n"
2577 ")\n"
2578 "{\n"
2579 "       float2 TexCoord = TexCoordBoth.xy;\n"
2580 "#ifdef USEOFFSETMAPPING\n"
2581 "       // apply offsetmapping\n"
2582 "       float2 TexCoordOffset = OffsetMapping(TexCoord, OffsetMapping_Scale, EyeVector, Texture_Normal);\n"
2583 "#define TexCoord TexCoordOffset\n"
2584 "#endif\n"
2585 "\n"
2586 "#ifdef USEALPHAKILL\n"
2587 "       if (tex2D(Texture_Color, TexCoord).a < 0.5)\n"
2588 "               discard;\n"
2589 "#endif\n"
2590 "\n"
2591 "#ifdef USEVERTEXTEXTUREBLEND\n"
2592 "       float alpha = tex2D(Texture_Color, TexCoord).a;\n"
2593 "       float terrainblend = clamp(float(gl_FrontColor.a) * alpha * 2.0 - 0.5, float(0.0), float(1.0));\n"
2594 "       //float terrainblend = min(float(gl_FrontColor.a) * alpha * 2.0, float(1.0));\n"
2595 "       //float terrainblend = float(gl_FrontColor.a) * alpha > 0.5;\n"
2596 "#endif\n"
2597 "\n"
2598 "#ifdef USEVERTEXTEXTUREBLEND\n"
2599 "       float3 surfacenormal = lerp(tex2D(Texture_SecondaryNormal, TexCoord2).rgb, tex2D(Texture_Normal, TexCoord).rgb, terrainblend) - float3(0.5, 0.5, 0.5);\n"
2600 "       float a = lerp(tex2D(Texture_SecondaryGloss, TexCoord2).a, tex2D(Texture_Gloss, TexCoord).a, terrainblend);\n"
2601 "#else\n"
2602 "       float3 surfacenormal = tex2D(Texture_Normal, TexCoord).rgb - float3(0.5, 0.5, 0.5);\n"
2603 "       float a = tex2D(Texture_Gloss, TexCoord).a;\n"
2604 "#endif\n"
2605 "\n"
2606 "#ifdef HLSL\n"
2607 "       gl_FragData0 = float4(normalize(surfacenormal.x * VectorS + surfacenormal.y * VectorT + surfacenormal.z * VectorR.xyz) * 0.5 + float3(0.5, 0.5, 0.5), a);\n"
2608 "       float Depth = VectorR.w / 256.0;\n"
2609 "       float4 depthcolor = float4(Depth,Depth*65536.0/255.0,Depth*16777216.0/255.0,0.0);\n"
2610 "//     float4 depthcolor = float4(Depth,Depth*256.0,Depth*65536.0,0.0);\n"
2611 "       depthcolor.yz -= floor(depthcolor.yz);\n"
2612 "       gl_FragData1 = depthcolor;\n"
2613 "#else\n"
2614 "       gl_FragColor = float4(normalize(surfacenormal.x * VectorS + surfacenormal.y * VectorT + surfacenormal.z * VectorR) * 0.5 + float3(0.5, 0.5, 0.5), a);\n"
2615 "#endif\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 : register(c8),\n"
2629 "uniform float4x4 ModelViewMatrix : register(c12),\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 "#ifdef HLSL\n"
2643 "float2 Pixel : VPOS,\n"
2644 "#else\n"
2645 "float2 Pixel : WPOS,\n"
2646 "#endif\n"
2647 "float4 ModelViewPosition : TEXCOORD0,\n"
2648 "uniform float4x4 ViewToLight : register(c44),\n"
2649 "uniform float2 ScreenToDepth : register(c33), // ScreenToDepth = float2(Far / (Far - Near), Far * Near / (Near - Far));\n"
2650 "uniform float3 LightPosition : register(c23),\n"
2651 "uniform half2 PixelToScreenTexCoord : register(c42),\n"
2652 "uniform half3 DeferredColor_Ambient : register(c9),\n"
2653 "uniform half3 DeferredColor_Diffuse : register(c10),\n"
2654 "#ifdef USESPECULAR\n"
2655 "uniform half3 DeferredColor_Specular : register(c11),\n"
2656 "uniform half SpecularPower : register(c36),\n"
2657 "#endif\n"
2658 "uniform sampler Texture_Attenuation : register(s9),\n"
2659 "uniform sampler Texture_ScreenDepth : register(s13),\n"
2660 "uniform sampler Texture_ScreenNormalMap : register(s14),\n"
2661 "\n"
2662 "#ifdef USECUBEFILTER\n"
2663 "uniform samplerCUBE Texture_Cube : register(s10),\n"
2664 "#endif\n"
2665 "\n"
2666 "#ifdef USESHADOWMAP2D\n"
2667 "# ifdef USESHADOWSAMPLER\n"
2668 "uniform sampler Texture_ShadowMap2D : register(s15),\n"
2669 "# else\n"
2670 "uniform sampler Texture_ShadowMap2D : register(s15),\n"
2671 "# endif\n"
2672 "#endif\n"
2673 "\n"
2674 "#ifdef USESHADOWMAPVSDCT\n"
2675 "uniform samplerCUBE Texture_CubeProjection : register(s12),\n"
2676 "#endif\n"
2677 "\n"
2678 "#if defined(USESHADOWMAP2D)\n"
2679 "uniform float2 ShadowMap_TextureScale : register(c35),\n"
2680 "uniform float4 ShadowMap_Parameters : register(c34),\n"
2681 "#endif\n"
2682 "\n"
2683 "out float4 gl_FragData0 : COLOR0,\n"
2684 "out float4 gl_FragData1 : COLOR1\n"
2685 ")\n"
2686 "{\n"
2687 "       // calculate viewspace pixel position\n"
2688 "       float2 ScreenTexCoord = Pixel * PixelToScreenTexCoord;\n"
2689 "       //ScreenTexCoord.y = ScreenTexCoord.y * -1 + 1; // Cg is opposite?\n"
2690 "       float3 position;\n"
2691 "#ifdef HLSL\n"
2692 "       position.z = texDepth2D(Texture_ScreenDepth, ScreenTexCoord) * 256.0;\n"
2693 "#else\n"
2694 "       position.z = ScreenToDepth.y / (texDepth2D(Texture_ScreenDepth, ScreenTexCoord) + ScreenToDepth.x);\n"
2695 "#endif\n"
2696 "       position.xy = ModelViewPosition.xy * (position.z / ModelViewPosition.z);\n"
2697 "       // decode viewspace pixel normal\n"
2698 "       half4 normalmap = half4(tex2D(Texture_ScreenNormalMap, ScreenTexCoord));\n"
2699 "       half3 surfacenormal = half3(normalize(normalmap.rgb - half3(0.5,0.5,0.5)));\n"
2700 "       // surfacenormal = pixel normal in viewspace\n"
2701 "       // LightVector = pixel to light in viewspace\n"
2702 "       // CubeVector = position in lightspace\n"
2703 "       // eyevector = pixel to view in viewspace\n"
2704 "       float3 CubeVector = mul(ViewToLight, float4(position,1)).xyz;\n"
2705 "       half fade = half(tex2D(Texture_Attenuation, float2(length(CubeVector), 0.0)).r);\n"
2706 "#ifdef USEDIFFUSE\n"
2707 "       // calculate diffuse shading\n"
2708 "       half3 lightnormal = half3(normalize(LightPosition - position));\n"
2709 "       half diffuse = half(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
2710 "#endif\n"
2711 "#ifdef USESPECULAR\n"
2712 "       // calculate directional shading\n"
2713 "       float3 eyevector = position * -1.0;\n"
2714 "#  ifdef USEEXACTSPECULARMATH\n"
2715 "       half specular = half(pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(eyevector)))*-1.0, 0.0)), SpecularPower * normalmap.a));\n"
2716 "#  else\n"
2717 "       half3 specularnormal = half3(normalize(lightnormal + half3(normalize(eyevector))));\n"
2718 "       half specular = half(pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * normalmap.a));\n"
2719 "#  endif\n"
2720 "#endif\n"
2721 "\n"
2722 "#if defined(USESHADOWMAP2D)\n"
2723 "       fade *= half(ShadowMapCompare(CubeVector, Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale\n"
2724 "#ifdef USESHADOWMAPVSDCT\n"
2725 ", Texture_CubeProjection\n"
2726 "#endif\n"
2727 "       ));\n"
2728 "#endif\n"
2729 "\n"
2730 "#ifdef USEDIFFUSE\n"
2731 "       gl_FragData0 = float4((DeferredColor_Ambient + DeferredColor_Diffuse * diffuse) * fade, 1.0);\n"
2732 "#else\n"
2733 "       gl_FragData0 = float4(DeferredColor_Ambient * fade, 1.0);\n"
2734 "#endif\n"
2735 "#ifdef USESPECULAR\n"
2736 "       gl_FragData1 = float4(DeferredColor_Specular * (specular * fade), 1.0);\n"
2737 "#else\n"
2738 "       gl_FragData1 = float4(0.0, 0.0, 0.0, 1.0);\n"
2739 "#endif\n"
2740 "\n"
2741 "# ifdef USECUBEFILTER\n"
2742 "       float3 cubecolor = texCUBE(Texture_Cube, CubeVector).rgb;\n"
2743 "       gl_FragData0.rgb *= cubecolor;\n"
2744 "       gl_FragData1.rgb *= cubecolor;\n"
2745 "# endif\n"
2746 "}\n"
2747 "#endif // FRAGMENT_SHADER\n"
2748 "#else // !MODE_DEFERREDLIGHTSOURCE\n"
2749 "\n"
2750 "\n"
2751 "\n"
2752 "\n"
2753 "#ifdef VERTEX_SHADER\n"
2754 "void main\n"
2755 "(\n"
2756 "float4 gl_Vertex : POSITION,\n"
2757 "uniform float4x4 ModelViewProjectionMatrix : register(c8),\n"
2758 "#if defined(USEVERTEXTEXTUREBLEND) || defined(MODE_VERTEXCOLOR)\n"
2759 "float4 gl_Color : COLOR0,\n"
2760 "#endif\n"
2761 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2762 "float4 gl_MultiTexCoord1 : TEXCOORD1,\n"
2763 "float4 gl_MultiTexCoord2 : TEXCOORD2,\n"
2764 "float4 gl_MultiTexCoord3 : TEXCOORD3,\n"
2765 "float4 gl_MultiTexCoord4 : TEXCOORD4,\n"
2766 "\n"
2767 "uniform float3 EyePosition : register(c24),\n"
2768 "uniform float4x4 TexMatrix : register(c0),\n"
2769 "#ifdef USEVERTEXTEXTUREBLEND\n"
2770 "uniform float4x4 BackgroundTexMatrix : register(c4),\n"
2771 "#endif\n"
2772 "#ifdef MODE_LIGHTSOURCE\n"
2773 "uniform float4x4 ModelToLight : register(c20),\n"
2774 "#endif\n"
2775 "#ifdef MODE_LIGHTSOURCE\n"
2776 "uniform float3 LightPosition : register(c27),\n"
2777 "#endif\n"
2778 "#ifdef MODE_LIGHTDIRECTION\n"
2779 "uniform float3 LightDir : register(c26),\n"
2780 "#endif\n"
2781 "uniform float4 FogPlane : register(c25),\n"
2782 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
2783 "uniform float3 LightPosition : register(c27),\n"
2784 "#endif\n"
2785 "#ifdef USESHADOWMAPORTHO\n"
2786 "uniform float4x4 ShadowMapMatrix : register(c16),\n"
2787 "#endif\n"
2788 "#if defined(MODE_VERTEXCOLOR) || defined(USEVERTEXTEXTUREBLEND)\n"
2789 "out float4 gl_FrontColor : COLOR,\n"
2790 "#endif\n"
2791 "out float4 TexCoordBoth : TEXCOORD0,\n"
2792 "#ifdef USELIGHTMAP\n"
2793 "out float2 TexCoordLightmap : TEXCOORD1,\n"
2794 "#endif\n"
2795 "#ifdef USEEYEVECTOR\n"
2796 "out float3 EyeVector : TEXCOORD2,\n"
2797 "#endif\n"
2798 "#ifdef USEREFLECTION\n"
2799 "out float4 ModelViewProjectionPosition : TEXCOORD3,\n"
2800 "#endif\n"
2801 "#ifdef USEFOG\n"
2802 "out float4 EyeVectorModelSpaceFogPlaneVertexDist : TEXCOORD4,\n"
2803 "#endif\n"
2804 "#if defined(MODE_LIGHTDIRECTION) && defined(USEDIFFUSE) || defined(USEDIFFUSE)\n"
2805 "out float3 LightVector : TEXCOORD1,\n"
2806 "#endif\n"
2807 "#ifdef MODE_LIGHTSOURCE\n"
2808 "out float3 CubeVector : TEXCOORD3,\n"
2809 "#endif\n"
2810 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY) || defined(USEREFLECTCUBE)\n"
2811 "out float3 VectorS : TEXCOORD5, // direction of S texcoord (sometimes crudely called tangent)\n"
2812 "out float3 VectorT : TEXCOORD6, // direction of T texcoord (sometimes crudely called binormal)\n"
2813 "out float3 VectorR : TEXCOORD7, // direction of R texcoord (surface normal)\n"
2814 "#endif\n"
2815 "#ifdef USESHADOWMAPORTHO\n"
2816 "out float3 ShadowMapTC : TEXCOORD3, // CONFLICTS WITH USEREFLECTION!\n"
2817 "#endif\n"
2818 "out float4 gl_Position : POSITION\n"
2819 ")\n"
2820 "{\n"
2821 "#if defined(MODE_VERTEXCOLOR) || defined(USEVERTEXTEXTUREBLEND)\n"
2822 "#ifdef HLSL\n"
2823 "       gl_FrontColor = gl_Color.bgra; // NOTE: D3DCOLOR is backwards\n"
2824 "#else\n"
2825 "       gl_FrontColor = gl_Color; // Cg is forward\n"
2826 "#endif\n"
2827 "#endif\n"
2828 "       // copy the surface texcoord\n"
2829 "       TexCoordBoth = mul(TexMatrix, gl_MultiTexCoord0);\n"
2830 "#ifdef USEVERTEXTEXTUREBLEND\n"
2831 "       TexCoordBoth.zw = mul(BackgroundTexMatrix, gl_MultiTexCoord0).xy;\n"
2832 "#endif\n"
2833 "#ifdef USELIGHTMAP\n"
2834 "       TexCoordLightmap = gl_MultiTexCoord4.xy;\n"
2835 "#endif\n"
2836 "\n"
2837 "#ifdef MODE_LIGHTSOURCE\n"
2838 "       // transform vertex position into light attenuation/cubemap space\n"
2839 "       // (-1 to +1 across the light box)\n"
2840 "       CubeVector = mul(ModelToLight, gl_Vertex).xyz;\n"
2841 "\n"
2842 "# ifdef USEDIFFUSE\n"
2843 "       // transform unnormalized light direction into tangent space\n"
2844 "       // (we use unnormalized to ensure that it interpolates correctly and then\n"
2845 "       //  normalize it per pixel)\n"
2846 "       float3 lightminusvertex = LightPosition - gl_Vertex.xyz;\n"
2847 "       LightVector.x = dot(lightminusvertex, gl_MultiTexCoord1.xyz);\n"
2848 "       LightVector.y = dot(lightminusvertex, gl_MultiTexCoord2.xyz);\n"
2849 "       LightVector.z = dot(lightminusvertex, gl_MultiTexCoord3.xyz);\n"
2850 "# endif\n"
2851 "#endif\n"
2852 "\n"
2853 "#if defined(MODE_LIGHTDIRECTION) && defined(USEDIFFUSE)\n"
2854 "       LightVector.x = dot(LightDir, gl_MultiTexCoord1.xyz);\n"
2855 "       LightVector.y = dot(LightDir, gl_MultiTexCoord2.xyz);\n"
2856 "       LightVector.z = dot(LightDir, gl_MultiTexCoord3.xyz);\n"
2857 "#endif\n"
2858 "\n"
2859 "       // transform unnormalized eye direction into tangent space\n"
2860 "#ifdef USEEYEVECTOR\n"
2861 "       float3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
2862 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
2863 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
2864 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
2865 "#endif\n"
2866 "\n"
2867 "#ifdef USEFOG\n"
2868 "       EyeVectorModelSpaceFogPlaneVertexDist.xyz = EyePosition - gl_Vertex.xyz;\n"
2869 "       EyeVectorModelSpaceFogPlaneVertexDist.w = dot(FogPlane, gl_Vertex);\n"
2870 "#endif\n"
2871 "\n"
2872 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
2873 "       VectorS = gl_MultiTexCoord1.xyz;\n"
2874 "       VectorT = gl_MultiTexCoord2.xyz;\n"
2875 "       VectorR = gl_MultiTexCoord3.xyz;\n"
2876 "#endif\n"
2877 "\n"
2878 "       // transform vertex to camera space, using ftransform to match non-VS rendering\n"
2879 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2880 "\n"
2881 "#ifdef USESHADOWMAPORTHO\n"
2882 "       ShadowMapTC = mul(ShadowMapMatrix, gl_Position).xyz;\n"
2883 "#endif\n"
2884 "\n"
2885 "#ifdef USEREFLECTION\n"
2886 "       ModelViewProjectionPosition = gl_Position;\n"
2887 "#endif\n"
2888 "}\n"
2889 "#endif // VERTEX_SHADER\n"
2890 "\n"
2891 "\n"
2892 "\n"
2893 "\n"
2894 "#ifdef FRAGMENT_SHADER\n"
2895 "void main\n"
2896 "(\n"
2897 "#ifdef USEDEFERREDLIGHTMAP\n"
2898 "#ifdef HLSL\n"
2899 "float2 Pixel : VPOS,\n"
2900 "#else\n"
2901 "float2 Pixel : WPOS,\n"
2902 "#endif\n"
2903 "#endif\n"
2904 "float4 gl_FrontColor : COLOR,\n"
2905 "float4 TexCoordBoth : TEXCOORD0,\n"
2906 "#ifdef USELIGHTMAP\n"
2907 "float2 TexCoordLightmap : TEXCOORD1,\n"
2908 "#endif\n"
2909 "#ifdef USEEYEVECTOR\n"
2910 "float3 EyeVector : TEXCOORD2,\n"
2911 "#endif\n"
2912 "#ifdef USEREFLECTION\n"
2913 "float4 ModelViewProjectionPosition : TEXCOORD3,\n"
2914 "#endif\n"
2915 "#ifdef USEFOG\n"
2916 "float4 EyeVectorModelSpaceFogPlaneVertexDist : TEXCOORD4,\n"
2917 "#endif\n"
2918 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_LIGHTDIRECTION)\n"
2919 "float3 LightVector : TEXCOORD1,\n"
2920 "#endif\n"
2921 "#ifdef MODE_LIGHTSOURCE\n"
2922 "float3 CubeVector : TEXCOORD3,\n"
2923 "#endif\n"
2924 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
2925 "float4 ModelViewPosition : TEXCOORD0,\n"
2926 "#endif\n"
2927 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY) || defined(USEREFLECTCUBE)\n"
2928 "float3 VectorS : TEXCOORD5, // direction of S texcoord (sometimes crudely called tangent)\n"
2929 "float3 VectorT : TEXCOORD6, // direction of T texcoord (sometimes crudely called binormal)\n"
2930 "float3 VectorR : TEXCOORD7, // direction of R texcoord (surface normal)\n"
2931 "#endif\n"
2932 "#ifdef USESHADOWMAPORTHO\n"
2933 "float3 ShadowMapTC : TEXCOORD3, // CONFLICTS WITH USEREFLECTION!\n"
2934 "#endif\n"
2935 "\n"
2936 "uniform sampler Texture_Normal : register(s0),\n"
2937 "uniform sampler Texture_Color : register(s1),\n"
2938 "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
2939 "uniform sampler Texture_Gloss : register(s2),\n"
2940 "#endif\n"
2941 "#ifdef USEGLOW\n"
2942 "uniform sampler Texture_Glow : register(s3),\n"
2943 "#endif\n"
2944 "#ifdef USEVERTEXTEXTUREBLEND\n"
2945 "uniform sampler Texture_SecondaryNormal : register(s4),\n"
2946 "uniform sampler Texture_SecondaryColor : register(s5),\n"
2947 "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
2948 "uniform sampler Texture_SecondaryGloss : register(s6),\n"
2949 "#endif\n"
2950 "#ifdef USEGLOW\n"
2951 "uniform sampler Texture_SecondaryGlow : register(s7),\n"
2952 "#endif\n"
2953 "#endif\n"
2954 "#ifdef USECOLORMAPPING\n"
2955 "uniform sampler Texture_Pants : register(s4),\n"
2956 "uniform sampler Texture_Shirt : register(s7),\n"
2957 "#endif\n"
2958 "#ifdef USEFOG\n"
2959 "uniform sampler Texture_FogHeightTexture : register(s14),\n"
2960 "uniform sampler Texture_FogMask : register(s8),\n"
2961 "#endif\n"
2962 "#ifdef USELIGHTMAP\n"
2963 "uniform sampler Texture_Lightmap : register(s9),\n"
2964 "#endif\n"
2965 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
2966 "uniform sampler Texture_Deluxemap : register(s10),\n"
2967 "#endif\n"
2968 "#ifdef USEREFLECTION\n"
2969 "uniform sampler Texture_Reflection : register(s7),\n"
2970 "#endif\n"
2971 "\n"
2972 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
2973 "uniform sampler Texture_ScreenDepth : register(s13),\n"
2974 "uniform sampler Texture_ScreenNormalMap : register(s14),\n"
2975 "#endif\n"
2976 "#ifdef USEDEFERREDLIGHTMAP\n"
2977 "uniform sampler Texture_ScreenDepth : register(s13),\n"
2978 "uniform sampler Texture_ScreenNormalMap : register(s14),\n"
2979 "uniform sampler Texture_ScreenDiffuse : register(s11),\n"
2980 "uniform sampler Texture_ScreenSpecular : register(s12),\n"
2981 "#endif\n"
2982 "\n"
2983 "#ifdef USECOLORMAPPING\n"
2984 "uniform half3 Color_Pants : register(c7),\n"
2985 "uniform half3 Color_Shirt : register(c8),\n"
2986 "#endif\n"
2987 "#ifdef USEFOG\n"
2988 "uniform float3 FogColor : register(c16),\n"
2989 "uniform float FogRangeRecip : register(c20),\n"
2990 "uniform float FogPlaneViewDist : register(c19),\n"
2991 "uniform float FogHeightFade : register(c17),\n"
2992 "#endif\n"
2993 "\n"
2994 "#ifdef USEOFFSETMAPPING\n"
2995 "uniform float OffsetMapping_Scale : register(c24),\n"
2996 "#endif\n"
2997 "\n"
2998 "#ifdef USEDEFERREDLIGHTMAP\n"
2999 "uniform half2 PixelToScreenTexCoord : register(c42),\n"
3000 "uniform half3 DeferredMod_Diffuse : register(c12),\n"
3001 "uniform half3 DeferredMod_Specular : register(c13),\n"
3002 "#endif\n"
3003 "uniform half3 Color_Ambient : register(c3),\n"
3004 "uniform half3 Color_Diffuse : register(c4),\n"
3005 "uniform half3 Color_Specular : register(c5),\n"
3006 "uniform half SpecularPower : register(c36),\n"
3007 "#ifdef USEGLOW\n"
3008 "uniform half3 Color_Glow : register(c6),\n"
3009 "#endif\n"
3010 "uniform half Alpha : register(c0),\n"
3011 "#ifdef USEREFLECTION\n"
3012 "uniform float4 DistortScaleRefractReflect : register(c14),\n"
3013 "uniform float4 ScreenScaleRefractReflect : register(c32),\n"
3014 "uniform float4 ScreenCenterRefractReflect : register(c31),\n"
3015 "uniform half4 ReflectColor : register(c26),\n"
3016 "#endif\n"
3017 "#ifdef USEREFLECTCUBE\n"
3018 "uniform float4x4 ModelToReflectCube : register(c48),\n"
3019 "uniform sampler Texture_ReflectMask : register(s5),\n"
3020 "uniform samplerCUBE Texture_ReflectCube : register(s6),\n"
3021 "#endif\n"
3022 "#ifdef MODE_LIGHTDIRECTION\n"
3023 "uniform half3 LightColor : register(c21),\n"
3024 "#endif\n"
3025 "#ifdef MODE_LIGHTSOURCE\n"
3026 "uniform half3 LightColor : register(c21),\n"
3027 "#endif\n"
3028 "\n"
3029 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE)\n"
3030 "uniform sampler Texture_Attenuation : register(s9),\n"
3031 "uniform samplerCUBE Texture_Cube : register(s10),\n"
3032 "#endif\n"
3033 "\n"
3034 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USESHADOWMAPORTHO)\n"
3035 "\n"
3036 "#ifdef USESHADOWMAP2D\n"
3037 "# ifdef USESHADOWSAMPLER\n"
3038 "uniform sampler Texture_ShadowMap2D : register(s15),\n"
3039 "# else\n"
3040 "uniform sampler Texture_ShadowMap2D : register(s15),\n"
3041 "# endif\n"
3042 "#endif\n"
3043 "\n"
3044 "#ifdef USESHADOWMAPVSDCT\n"
3045 "uniform samplerCUBE Texture_CubeProjection : register(s12),\n"
3046 "#endif\n"
3047 "\n"
3048 "#if defined(USESHADOWMAP2D)\n"
3049 "uniform float2 ShadowMap_TextureScale : register(c35),\n"
3050 "uniform float4 ShadowMap_Parameters : register(c34),\n"
3051 "#endif\n"
3052 "#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE) && !defined(USESHADOWMAPORTHO)\n"
3053 "\n"
3054 "out float4 gl_FragColor : COLOR\n"
3055 ")\n"
3056 "{\n"
3057 "       float2 TexCoord = TexCoordBoth.xy;\n"
3058 "#ifdef USEVERTEXTEXTUREBLEND\n"
3059 "       float2 TexCoord2 = TexCoordBoth.zw;\n"
3060 "#endif\n"
3061 "#ifdef USEOFFSETMAPPING\n"
3062 "       // apply offsetmapping\n"
3063 "       float2 TexCoordOffset = OffsetMapping(TexCoord, OffsetMapping_Scale, EyeVector, Texture_Normal);\n"
3064 "#define TexCoord TexCoordOffset\n"
3065 "#endif\n"
3066 "\n"
3067 "       // combine the diffuse textures (base, pants, shirt)\n"
3068 "       half4 color = half4(tex2D(Texture_Color, TexCoord));\n"
3069 "#ifdef USEALPHAKILL\n"
3070 "       if (color.a < 0.5)\n"
3071 "               discard;\n"
3072 "#endif\n"
3073 "       color.a *= Alpha;\n"
3074 "#ifdef USECOLORMAPPING\n"
3075 "       color.rgb += half3(tex2D(Texture_Pants, TexCoord).rgb) * Color_Pants + half3(tex2D(Texture_Shirt, TexCoord).rgb) * Color_Shirt;\n"
3076 "#endif\n"
3077 "#ifdef USEVERTEXTEXTUREBLEND\n"
3078 "       half terrainblend = clamp(half(gl_FrontColor.a) * color.a * 2.0 - 0.5, half(0.0), half(1.0));\n"
3079 "       //half terrainblend = min(half(gl_FrontColor.a) * color.a * 2.0, half(1.0));\n"
3080 "       //half terrainblend = half(gl_FrontColor.a) * color.a > 0.5;\n"
3081 "       color.rgb = half3(lerp(tex2D(Texture_SecondaryColor, TexCoord2).rgb, float3(color.rgb), terrainblend));\n"
3082 "       color.a = 1.0;\n"
3083 "       //color = half4(lerp(float4(1, 0, 0, 1), color, terrainblend));\n"
3084 "#endif\n"
3085 "\n"
3086 "       // get the surface normal\n"
3087 "#ifdef USEVERTEXTEXTUREBLEND\n"
3088 "       half3 surfacenormal = normalize(half3(lerp(tex2D(Texture_SecondaryNormal, TexCoord2).rgb, tex2D(Texture_Normal, TexCoord).rgb, terrainblend)) - half3(0.5, 0.5, 0.5));\n"
3089 "#else\n"
3090 "       half3 surfacenormal = half3(normalize(half3(tex2D(Texture_Normal, TexCoord).rgb) - half3(0.5, 0.5, 0.5)));\n"
3091 "#endif\n"
3092 "\n"
3093 "       // get the material colors\n"
3094 "       half3 diffusetex = color.rgb;\n"
3095 "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
3096 "# ifdef USEVERTEXTEXTUREBLEND\n"
3097 "       half4 glosstex = half4(lerp(tex2D(Texture_SecondaryGloss, TexCoord2), tex2D(Texture_Gloss, TexCoord), terrainblend));\n"
3098 "# else\n"
3099 "       half4 glosstex = half4(tex2D(Texture_Gloss, TexCoord));\n"
3100 "# endif\n"
3101 "#endif\n"
3102 "\n"
3103 "#ifdef USEREFLECTCUBE\n"
3104 "       float3 TangentReflectVector = reflect(-EyeVector, surfacenormal);\n"
3105 "       float3 ModelReflectVector = TangentReflectVector.x * VectorS + TangentReflectVector.y * VectorT + TangentReflectVector.z * VectorR;\n"
3106 "       float3 ReflectCubeTexCoord = mul(ModelToReflectCube, float4(ModelReflectVector, 0)).xyz;\n"
3107 "       diffusetex += half3(tex2D(Texture_ReflectMask, TexCoord).rgb) * half3(texCUBE(Texture_ReflectCube, ReflectCubeTexCoord).rgb);\n"
3108 "#endif\n"
3109 "\n"
3110 "\n"
3111 "\n"
3112 "\n"
3113 "#ifdef MODE_LIGHTSOURCE\n"
3114 "       // light source\n"
3115 "#ifdef USEDIFFUSE\n"
3116 "       half3 lightnormal = half3(normalize(LightVector));\n"
3117 "       half diffuse = half(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
3118 "       color.rgb = diffusetex * (Color_Ambient + diffuse * Color_Diffuse);\n"
3119 "#ifdef USESPECULAR\n"
3120 "#ifdef USEEXACTSPECULARMATH\n"
3121 "       half specular = half(pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a));\n"
3122 "#else\n"
3123 "       half3 specularnormal = half3(normalize(lightnormal + half3(normalize(EyeVector))));\n"
3124 "       half specular = half(pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a));\n"
3125 "#endif\n"
3126 "       color.rgb += glosstex.rgb * (specular * Color_Specular);\n"
3127 "#endif\n"
3128 "#else\n"
3129 "       color.rgb = diffusetex * Color_Ambient;\n"
3130 "#endif\n"
3131 "       color.rgb *= LightColor;\n"
3132 "       color.rgb *= half(tex2D(Texture_Attenuation, float2(length(CubeVector), 0.0)).r);\n"
3133 "#if defined(USESHADOWMAP2D)\n"
3134 "       color.rgb *= half(ShadowMapCompare(CubeVector, Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale\n"
3135 "#ifdef USESHADOWMAPVSDCT\n"
3136 ", Texture_CubeProjection\n"
3137 "#endif\n"
3138 "       ));\n"
3139 "\n"
3140 "#endif\n"
3141 "# ifdef USECUBEFILTER\n"
3142 "       color.rgb *= half3(texCUBE(Texture_Cube, CubeVector).rgb);\n"
3143 "# endif\n"
3144 "\n"
3145 "#ifdef USESHADOWMAP2D\n"
3146 "#ifdef USESHADOWMAPVSDCT\n"
3147 "//     float3 shadowmaptc = GetShadowMapTC2D(CubeVector, ShadowMap_Parameters, Texture_CubeProjection);\n"
3148 "#else\n"
3149 "//     float3 shadowmaptc = GetShadowMapTC2D(CubeVector, ShadowMap_Parameters);\n"
3150 "#endif\n"
3151 "//     color.rgb = half3(tex2D(Texture_ShadowMap2D, float2(0.1,0.1)).rgb);\n"
3152 "//     color.rgb = half3(tex2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale).rgb);\n"
3153 "//     color.rgb = half3(shadowmaptc.xyz * float3(ShadowMap_TextureScale,1.0));\n"
3154 "//     color.r = half(texDepth2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale));\n"
3155 "//     color.rgb = half3(tex2D(Texture_ShadowMap2D, float2(0.1,0.1)).rgb);\n"
3156 "//     color.rgb = half3(tex2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale).rgb);\n"
3157 "//     color.rgb = half3(shadowmaptc.xyz * float3(ShadowMap_TextureScale,1.0));\n"
3158 "//     color.r = half(texDepth2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale));\n"
3159 "//     color.r = half(shadowmaptc.z - texDepth2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale));\n"
3160 "//     color.r = half(shadowmaptc.z);\n"
3161 "//     color.r = half(texDepth2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale));\n"
3162 "//     color.r = half(shadowmaptc.z);\n"
3163 "//     color.r = 1;\n"
3164 "//     color.rgb = abs(CubeVector);\n"
3165 "#endif\n"
3166 "//     color.rgb = half3(1,1,1);\n"
3167 "#endif // MODE_LIGHTSOURCE\n"
3168 "\n"
3169 "\n"
3170 "\n"
3171 "\n"
3172 "#ifdef MODE_LIGHTDIRECTION\n"
3173 "#define SHADING\n"
3174 "#ifdef USEDIFFUSE\n"
3175 "       half3 lightnormal = half3(normalize(LightVector));\n"
3176 "#endif\n"
3177 "#define lightcolor LightColor\n"
3178 "#endif // MODE_LIGHTDIRECTION\n"
3179 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
3180 "#define SHADING\n"
3181 "       // deluxemap lightmapping using light vectors in modelspace (q3map2 -light -deluxe)\n"
3182 "       half3 lightnormal_modelspace = half3(tex2D(Texture_Deluxemap, TexCoordLightmap).rgb) * 2.0 + half3(-1.0, -1.0, -1.0);\n"
3183 "       half3 lightcolor = half3(tex2D(Texture_Lightmap, TexCoordLightmap).rgb);\n"
3184 "       // convert modelspace light vector to tangentspace\n"
3185 "       half3 lightnormal;\n"
3186 "       lightnormal.x = dot(lightnormal_modelspace, half3(VectorS));\n"
3187 "       lightnormal.y = dot(lightnormal_modelspace, half3(VectorT));\n"
3188 "       lightnormal.z = dot(lightnormal_modelspace, half3(VectorR));\n"
3189 "       // calculate directional shading (and undoing the existing angle attenuation on the lightmap by the division)\n"
3190 "       // note that q3map2 is too stupid to calculate proper surface normals when q3map_nonplanar\n"
3191 "       // is used (the lightmap and deluxemap coords correspond to virtually random coordinates\n"
3192 "       // on that luxel, and NOT to its center, because recursive triangle subdivision is used\n"
3193 "       // to map the luxels to coordinates on the draw surfaces), which also causes\n"
3194 "       // deluxemaps to be wrong because light contributions from the wrong side of the surface\n"
3195 "       // are added up. To prevent divisions by zero or strong exaggerations, a max()\n"
3196 "       // nudge is done here at expense of some additional fps. This is ONLY needed for\n"
3197 "       // deluxemaps, tangentspace deluxemap avoid this problem by design.\n"
3198 "       lightcolor *= 1.0 / max(0.25, lightnormal.z);\n"
3199 "#endif // MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
3200 "#ifdef MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
3201 "#define SHADING\n"
3202 "       // deluxemap lightmapping using light vectors in tangentspace (hmap2 -light)\n"
3203 "       half3 lightnormal = half3(tex2D(Texture_Deluxemap, TexCoordLightmap).rgb) * 2.0 + half3(-1.0, -1.0, -1.0);\n"
3204 "       half3 lightcolor = half3(tex2D(Texture_Lightmap, TexCoordLightmap).rgb);\n"
3205 "#endif\n"
3206 "\n"
3207 "\n"
3208 "\n"
3209 "\n"
3210 "#ifdef MODE_FAKELIGHT\n"
3211 "#define SHADING\n"
3212 "half3 lightnormal = half3(normalize(EyeVector));\n"
3213 "half3 lightcolor = half3(1.0);\n"
3214 "#endif // MODE_FAKELIGHT\n"
3215 "\n"
3216 "\n"
3217 "\n"
3218 "\n"
3219 "#ifdef MODE_LIGHTMAP\n"
3220 "       color.rgb = diffusetex * (Color_Ambient + half3(tex2D(Texture_Lightmap, TexCoordLightmap).rgb) * Color_Diffuse);\n"
3221 "#endif // MODE_LIGHTMAP\n"
3222 "#ifdef MODE_VERTEXCOLOR\n"
3223 "       color.rgb = diffusetex * (Color_Ambient + half3(gl_FrontColor.rgb) * Color_Diffuse);\n"
3224 "#endif // MODE_VERTEXCOLOR\n"
3225 "#ifdef MODE_FLATCOLOR\n"
3226 "       color.rgb = diffusetex * Color_Ambient;\n"
3227 "#endif // MODE_FLATCOLOR\n"
3228 "\n"
3229 "\n"
3230 "\n"
3231 "\n"
3232 "#ifdef SHADING\n"
3233 "# ifdef USEDIFFUSE\n"
3234 "       half diffuse = half(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
3235 "#  ifdef USESPECULAR\n"
3236 "#   ifdef USEEXACTSPECULARMATH\n"
3237 "       half specular = half(pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a));\n"
3238 "#   else\n"
3239 "       half3 specularnormal = half3(normalize(lightnormal + half3(normalize(EyeVector))));\n"
3240 "       half specular = half(pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a));\n"
3241 "#   endif\n"
3242 "       color.rgb = diffusetex * Color_Ambient + (diffusetex * Color_Diffuse * diffuse + glosstex.rgb * Color_Specular * specular) * lightcolor;\n"
3243 "#  else\n"
3244 "       color.rgb = diffusetex * (Color_Ambient + Color_Diffuse * diffuse * lightcolor);\n"
3245 "#  endif\n"
3246 "# else\n"
3247 "       color.rgb = diffusetex * Color_Ambient;\n"
3248 "# endif\n"
3249 "#endif\n"
3250 "\n"
3251 "#ifdef USESHADOWMAPORTHO\n"
3252 "       color.rgb *= half(ShadowMapCompare(ShadowMapTC, Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale));\n"
3253 "#endif\n"
3254 "\n"
3255 "#ifdef USEDEFERREDLIGHTMAP\n"
3256 "       float2 ScreenTexCoord = Pixel * PixelToScreenTexCoord;\n"
3257 "       color.rgb += diffusetex * half3(tex2D(Texture_ScreenDiffuse, ScreenTexCoord).rgb) * DeferredMod_Diffuse;\n"
3258 "       color.rgb += glosstex.rgb * half3(tex2D(Texture_ScreenSpecular, ScreenTexCoord).rgb) * DeferredMod_Specular;\n"
3259 "//     color.rgb = half3(tex2D(Texture_ScreenDepth, ScreenTexCoord).rgb);\n"
3260 "//     color.r = half(texDepth2D(Texture_ScreenDepth, ScreenTexCoord)) * 1.0;\n"
3261 "#endif\n"
3262 "\n"
3263 "#ifdef USEGLOW\n"
3264 "#ifdef USEVERTEXTEXTUREBLEND\n"
3265 "       color.rgb += half3(lerp(tex2D(Texture_SecondaryGlow, TexCoord2).rgb, tex2D(Texture_Glow, TexCoord).rgb, terrainblend)) * Color_Glow;\n"
3266 "#else\n"
3267 "       color.rgb += half3(tex2D(Texture_Glow, TexCoord).rgb) * Color_Glow;\n"
3268 "#endif\n"
3269 "#endif\n"
3270 "\n"
3271 "#ifdef USEFOG\n"
3272 "       color.rgb = FogVertex(color.rgb, FogColor, EyeVectorModelSpaceFogPlaneVertexDist.xyz, EyeVectorModelSpaceFogPlaneVertexDist.w, FogRangeRecip, FogPlaneViewDist, FogHeightFade, Texture_FogMask, Texture_FogHeightTexture);\n"
3273 "#endif\n"
3274 "\n"
3275 "       // 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"
3276 "#ifdef USEREFLECTION\n"
3277 "       float4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
3278 "       //float4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(half3(tex2D(Texture_Normal, TexCoord).rgb) - half3(0.5,0.5,0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
3279 "       float2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW.zw + ScreenCenterRefractReflect.zw;\n"
3280 "       float2 ScreenTexCoord = SafeScreenTexCoord + float3(normalize(half3(tex2D(Texture_Normal, TexCoord).rgb) - half3(0.5,0.5,0.5))).xy * DistortScaleRefractReflect.zw;\n"
3281 "       // FIXME temporary hack to detect the case that the reflection\n"
3282 "       // gets blackened at edges due to leaving the area that contains actual\n"
3283 "       // content.\n"
3284 "       // Remove this 'ack once we have a better way to stop this thing from\n"
3285 "       // 'appening.\n"
3286 "       float f = min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(0.01, 0.01)).rgb) / 0.05);\n"
3287 "       f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(0.01, -0.01)).rgb) / 0.05);\n"
3288 "       f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(-0.01, 0.01)).rgb) / 0.05);\n"
3289 "       f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(-0.01, -0.01)).rgb) / 0.05);\n"
3290 "       ScreenTexCoord = lerp(SafeScreenTexCoord, ScreenTexCoord, f);\n"
3291 "       color.rgb = lerp(color.rgb, half3(tex2D(Texture_Reflection, ScreenTexCoord).rgb) * ReflectColor.rgb, ReflectColor.a);\n"
3292 "#endif\n"
3293 "\n"
3294 "       gl_FragColor = float4(color);\n"
3295 "}\n"
3296 "#endif // FRAGMENT_SHADER\n"
3297 "\n"
3298 "#endif // !MODE_DEFERREDLIGHTSOURCE\n"
3299 "#endif // !MODE_DEFERREDGEOMETRY\n"
3300 "#endif // !MODE_WATER\n"
3301 "#endif // !MODE_REFRACTION\n"
3302 "#endif // !MODE_BLOOMBLUR\n"
3303 "#endif // !MODE_GENERIC\n"
3304 "#endif // !MODE_POSTPROCESS\n"
3305 "#endif // !MODE_SHOWDEPTH\n"
3306 "#endif // !MODE_DEPTH_OR_SHADOW\n"
3307 ;
3308
3309 char *glslshaderstring = NULL;
3310 char *cgshaderstring = NULL;
3311 char *hlslshaderstring = NULL;
3312
3313 //=======================================================================================================================================================
3314
3315 typedef struct shaderpermutationinfo_s
3316 {
3317         const char *pretext;
3318         const char *name;
3319 }
3320 shaderpermutationinfo_t;
3321
3322 typedef struct shadermodeinfo_s
3323 {
3324         const char *vertexfilename;
3325         const char *geometryfilename;
3326         const char *fragmentfilename;
3327         const char *pretext;
3328         const char *name;
3329 }
3330 shadermodeinfo_t;
3331
3332 typedef enum shaderpermutation_e
3333 {
3334         SHADERPERMUTATION_DIFFUSE = 1<<0, ///< (lightsource) whether to use directional shading
3335         SHADERPERMUTATION_VERTEXTEXTUREBLEND = 1<<1, ///< indicates this is a two-layer material blend based on vertex alpha (q3bsp)
3336         SHADERPERMUTATION_VIEWTINT = 1<<2, ///< view tint (postprocessing only)
3337         SHADERPERMUTATION_COLORMAPPING = 1<<3, ///< indicates this is a colormapped skin
3338         SHADERPERMUTATION_SATURATION = 1<<4, ///< saturation (postprocessing only)
3339         SHADERPERMUTATION_FOGINSIDE = 1<<5, ///< tint the color by fog color or black if using additive blend mode
3340         SHADERPERMUTATION_FOGOUTSIDE = 1<<6, ///< tint the color by fog color or black if using additive blend mode
3341         SHADERPERMUTATION_FOGHEIGHTTEXTURE = 1<<7, ///< fog color and density determined by texture mapped on vertical axis
3342         SHADERPERMUTATION_GAMMARAMPS = 1<<8, ///< gamma (postprocessing only)
3343         SHADERPERMUTATION_CUBEFILTER = 1<<9, ///< (lightsource) use cubemap light filter
3344         SHADERPERMUTATION_GLOW = 1<<10, ///< (lightmap) blend in an additive glow texture
3345         SHADERPERMUTATION_BLOOM = 1<<11, ///< bloom (postprocessing only)
3346         SHADERPERMUTATION_SPECULAR = 1<<12, ///< (lightsource or deluxemapping) render specular effects
3347         SHADERPERMUTATION_POSTPROCESSING = 1<<13, ///< user defined postprocessing (postprocessing only)
3348         SHADERPERMUTATION_REFLECTION = 1<<14, ///< normalmap-perturbed reflection of the scene infront of the surface, preformed as an overlay on the surface
3349         SHADERPERMUTATION_OFFSETMAPPING = 1<<15, ///< adjust texcoords to roughly simulate a displacement mapped surface
3350         SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING = 1<<16, ///< adjust texcoords to accurately simulate a displacement mapped surface (requires OFFSETMAPPING to also be set!)
3351         SHADERPERMUTATION_SHADOWMAP2D = 1<<17, ///< (lightsource) use shadowmap texture as light filter
3352         SHADERPERMUTATION_SHADOWMAPPCF = 1<<18, ///< (lightsource) use percentage closer filtering on shadowmap test results
3353         SHADERPERMUTATION_SHADOWMAPPCF2 = 1<<19, ///< (lightsource) use higher quality percentage closer filtering on shadowmap test results
3354         SHADERPERMUTATION_SHADOWSAMPLER = 1<<20, ///< (lightsource) use hardware shadowmap test
3355         SHADERPERMUTATION_SHADOWMAPVSDCT = 1<<21, ///< (lightsource) use virtual shadow depth cube texture for shadowmap indexing
3356         SHADERPERMUTATION_SHADOWMAPORTHO = 1<<22, //< (lightsource) use orthographic shadowmap projection
3357         SHADERPERMUTATION_DEFERREDLIGHTMAP = 1<<23, ///< (lightmap) read Texture_ScreenDiffuse/Specular textures and add them on top of lightmapping
3358         SHADERPERMUTATION_ALPHAKILL = 1<<24, ///< (deferredgeometry) discard pixel if diffuse texture alpha below 0.5
3359         SHADERPERMUTATION_REFLECTCUBE = 1<<25, ///< fake reflections using global cubemap (not HDRI light probe)
3360         SHADERPERMUTATION_NORMALMAPSCROLLBLEND = 1<<26, // (water) counter-direction normalmaps scrolling
3361         SHADERPERMUTATION_LIMIT = 1<<27, ///< size of permutations array
3362         SHADERPERMUTATION_COUNT = 27 ///< size of shaderpermutationinfo array
3363 }
3364 shaderpermutation_t;
3365
3366 // NOTE: MUST MATCH ORDER OF SHADERPERMUTATION_* DEFINES!
3367 shaderpermutationinfo_t shaderpermutationinfo[SHADERPERMUTATION_COUNT] =
3368 {
3369         {"#define USEDIFFUSE\n", " diffuse"},
3370         {"#define USEVERTEXTEXTUREBLEND\n", " vertextextureblend"},
3371         {"#define USEVIEWTINT\n", " viewtint"},
3372         {"#define USECOLORMAPPING\n", " colormapping"},
3373         {"#define USESATURATION\n", " saturation"},
3374         {"#define USEFOGINSIDE\n", " foginside"},
3375         {"#define USEFOGOUTSIDE\n", " fogoutside"},
3376         {"#define USEFOGHEIGHTTEXTURE\n", " fogheighttexture"},
3377         {"#define USEGAMMARAMPS\n", " gammaramps"},
3378         {"#define USECUBEFILTER\n", " cubefilter"},
3379         {"#define USEGLOW\n", " glow"},
3380         {"#define USEBLOOM\n", " bloom"},
3381         {"#define USESPECULAR\n", " specular"},
3382         {"#define USEPOSTPROCESSING\n", " postprocessing"},
3383         {"#define USEREFLECTION\n", " reflection"},
3384         {"#define USEOFFSETMAPPING\n", " offsetmapping"},
3385         {"#define USEOFFSETMAPPING_RELIEFMAPPING\n", " reliefmapping"},
3386         {"#define USESHADOWMAP2D\n", " shadowmap2d"},
3387         {"#define USESHADOWMAPPCF 1\n", " shadowmappcf"},
3388         {"#define USESHADOWMAPPCF 2\n", " shadowmappcf2"},
3389         {"#define USESHADOWSAMPLER\n", " shadowsampler"},
3390         {"#define USESHADOWMAPVSDCT\n", " shadowmapvsdct"},
3391         {"#define USESHADOWMAPORTHO\n", " shadowmaportho"},
3392         {"#define USEDEFERREDLIGHTMAP\n", " deferredlightmap"},
3393         {"#define USEALPHAKILL\n", " alphakill"},
3394         {"#define USEREFLECTCUBE\n", " reflectcube"},
3395         {"#define USENORMALMAPSCROLLBLEND\n", " normalmapscrollblend"},
3396 };
3397
3398 /// this enum is multiplied by SHADERPERMUTATION_MODEBASE
3399 typedef enum shadermode_e
3400 {
3401         SHADERMODE_GENERIC, ///< (particles/HUD/etc) vertex color, optionally multiplied by one texture
3402         SHADERMODE_POSTPROCESS, ///< postprocessing shader (r_glsl_postprocess)
3403         SHADERMODE_DEPTH_OR_SHADOW, ///< (depthfirst/shadows) vertex shader only
3404         SHADERMODE_FLATCOLOR, ///< (lightmap) modulate texture by uniform color (q1bsp, q3bsp)
3405         SHADERMODE_VERTEXCOLOR, ///< (lightmap) modulate texture by vertex colors (q3bsp)
3406         SHADERMODE_LIGHTMAP, ///< (lightmap) modulate texture by lightmap texture (q1bsp, q3bsp)
3407         SHADERMODE_FAKELIGHT, ///< (fakelight) modulate texture by "fake" lighting (no lightmaps, no nothing)
3408         SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE, ///< (lightmap) use directional pixel shading from texture containing modelspace light directions (q3bsp deluxemap)
3409         SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE, ///< (lightmap) use directional pixel shading from texture containing tangentspace light directions (q1bsp deluxemap)
3410         SHADERMODE_LIGHTDIRECTION, ///< (lightmap) use directional pixel shading from fixed light direction (q3bsp)
3411         SHADERMODE_LIGHTSOURCE, ///< (lightsource) use directional pixel shading from light source (rtlight)
3412         SHADERMODE_REFRACTION, ///< refract background (the material is rendered normally after this pass)
3413         SHADERMODE_WATER, ///< refract background and reflection (the material is rendered normally after this pass)
3414         SHADERMODE_SHOWDEPTH, ///< (debugging) renders depth as color
3415         SHADERMODE_DEFERREDGEOMETRY, ///< (deferred) render material properties to screenspace geometry buffers
3416         SHADERMODE_DEFERREDLIGHTSOURCE, ///< (deferred) use directional pixel shading from light source (rtlight) on screenspace geometry buffers
3417         SHADERMODE_COUNT
3418 }
3419 shadermode_t;
3420
3421 // NOTE: MUST MATCH ORDER OF SHADERMODE_* ENUMS!
3422 shadermodeinfo_t glslshadermodeinfo[SHADERMODE_COUNT] =
3423 {
3424         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_GENERIC\n", " generic"},
3425         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_POSTPROCESS\n", " postprocess"},
3426         {"glsl/default.glsl", NULL, NULL               , "#define MODE_DEPTH_OR_SHADOW\n", " depth/shadow"},
3427         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_FLATCOLOR\n", " flatcolor"},
3428         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_VERTEXCOLOR\n", " vertexcolor"},
3429         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTMAP\n", " lightmap"},
3430         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_FAKELIGHT\n", " fakelight"},
3431         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
3432         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
3433         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTION\n", " lightdirection"},
3434         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTSOURCE\n", " lightsource"},
3435         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_REFRACTION\n", " refraction"},
3436         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_WATER\n", " water"},
3437         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_SHOWDEPTH\n", " showdepth"},
3438         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_DEFERREDGEOMETRY\n", " deferredgeometry"},
3439         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_DEFERREDLIGHTSOURCE\n", " deferredlightsource"},
3440 };
3441
3442 #ifdef SUPPORTCG
3443 shadermodeinfo_t cgshadermodeinfo[SHADERMODE_COUNT] =
3444 {
3445         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_GENERIC\n", " generic"},
3446         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_POSTPROCESS\n", " postprocess"},
3447         {"cg/default.cg", NULL, NULL           , "#define MODE_DEPTH_OR_SHADOW\n", " depth"},
3448         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_FLATCOLOR\n", " flatcolor"},
3449         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_VERTEXCOLOR\n", " vertexcolor"},
3450         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTMAP\n", " lightmap"},
3451         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_FAKELIGHT\n", " fakelight"},
3452         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
3453         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
3454         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTDIRECTION\n", " lightdirection"},
3455         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTSOURCE\n", " lightsource"},
3456         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_REFRACTION\n", " refraction"},
3457         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_WATER\n", " water"},
3458         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_SHOWDEPTH\n", " showdepth"},
3459         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_DEFERREDGEOMETRY\n", " deferredgeometry"},
3460         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_DEFERREDLIGHTSOURCE\n", " deferredlightsource"},
3461 };
3462 #endif
3463
3464 #ifdef SUPPORTD3D
3465 shadermodeinfo_t hlslshadermodeinfo[SHADERMODE_COUNT] =
3466 {
3467         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_GENERIC\n", " generic"},
3468         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_POSTPROCESS\n", " postprocess"},
3469         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_DEPTH_OR_SHADOW\n", " depth"},
3470         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_FLATCOLOR\n", " flatcolor"},
3471         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_VERTEXCOLOR\n", " vertexcolor"},
3472         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTMAP\n", " lightmap"},
3473         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
3474         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
3475         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTDIRECTION\n", " lightdirection"},
3476         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTSOURCE\n", " lightsource"},
3477         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_REFRACTION\n", " refraction"},
3478         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_WATER\n", " water"},
3479         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_SHOWDEPTH\n", " showdepth"},
3480         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_DEFERREDGEOMETRY\n", " deferredgeometry"},
3481         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_DEFERREDLIGHTSOURCE\n", " deferredlightsource"},
3482 };
3483 #endif
3484
3485 struct r_glsl_permutation_s;
3486 typedef struct r_glsl_permutation_s
3487 {
3488         /// hash lookup data
3489         struct r_glsl_permutation_s *hashnext;
3490         unsigned int mode;
3491         unsigned int permutation;
3492
3493         /// indicates if we have tried compiling this permutation already
3494         qboolean compiled;
3495         /// 0 if compilation failed
3496         int program;
3497         /// locations of detected uniforms in program object, or -1 if not found
3498         int loc_Texture_First;
3499         int loc_Texture_Second;
3500         int loc_Texture_GammaRamps;
3501         int loc_Texture_Normal;
3502         int loc_Texture_Color;
3503         int loc_Texture_Gloss;
3504         int loc_Texture_Glow;
3505         int loc_Texture_SecondaryNormal;
3506         int loc_Texture_SecondaryColor;
3507         int loc_Texture_SecondaryGloss;
3508         int loc_Texture_SecondaryGlow;
3509         int loc_Texture_Pants;
3510         int loc_Texture_Shirt;
3511         int loc_Texture_FogHeightTexture;
3512         int loc_Texture_FogMask;
3513         int loc_Texture_Lightmap;
3514         int loc_Texture_Deluxemap;
3515         int loc_Texture_Attenuation;
3516         int loc_Texture_Cube;
3517         int loc_Texture_Refraction;
3518         int loc_Texture_Reflection;
3519         int loc_Texture_ShadowMap2D;
3520         int loc_Texture_CubeProjection;
3521         int loc_Texture_ScreenDepth;
3522         int loc_Texture_ScreenNormalMap;
3523         int loc_Texture_ScreenDiffuse;
3524         int loc_Texture_ScreenSpecular;
3525         int loc_Texture_ReflectMask;
3526         int loc_Texture_ReflectCube;
3527         int loc_Alpha;
3528         int loc_BloomBlur_Parameters;
3529         int loc_ClientTime;
3530         int loc_Color_Ambient;
3531         int loc_Color_Diffuse;
3532         int loc_Color_Specular;
3533         int loc_Color_Glow;
3534         int loc_Color_Pants;
3535         int loc_Color_Shirt;
3536         int loc_DeferredColor_Ambient;
3537         int loc_DeferredColor_Diffuse;
3538         int loc_DeferredColor_Specular;
3539         int loc_DeferredMod_Diffuse;
3540         int loc_DeferredMod_Specular;
3541         int loc_DistortScaleRefractReflect;
3542         int loc_EyePosition;
3543         int loc_FogColor;
3544         int loc_FogHeightFade;
3545         int loc_FogPlane;
3546         int loc_FogPlaneViewDist;
3547         int loc_FogRangeRecip;
3548         int loc_LightColor;
3549         int loc_LightDir;
3550         int loc_LightPosition;
3551         int loc_OffsetMapping_Scale;
3552         int loc_PixelSize;
3553         int loc_ReflectColor;
3554         int loc_ReflectFactor;
3555         int loc_ReflectOffset;
3556         int loc_RefractColor;
3557         int loc_Saturation;
3558         int loc_ScreenCenterRefractReflect;
3559         int loc_ScreenScaleRefractReflect;
3560         int loc_ScreenToDepth;
3561         int loc_ShadowMap_Parameters;
3562         int loc_ShadowMap_TextureScale;
3563         int loc_SpecularPower;
3564         int loc_UserVec1;
3565         int loc_UserVec2;
3566         int loc_UserVec3;
3567         int loc_UserVec4;
3568         int loc_ViewTintColor;
3569         int loc_ViewToLight;
3570         int loc_ModelToLight;
3571         int loc_TexMatrix;
3572         int loc_BackgroundTexMatrix;
3573         int loc_ModelViewProjectionMatrix;
3574         int loc_ModelViewMatrix;
3575         int loc_PixelToScreenTexCoord;
3576         int loc_ModelToReflectCube;
3577         int loc_ShadowMapMatrix;
3578         int loc_BloomColorSubtract;
3579         int loc_NormalmapScrollBlend;
3580 }
3581 r_glsl_permutation_t;
3582
3583 #define SHADERPERMUTATION_HASHSIZE 256
3584
3585
3586 // non-degradable "lightweight" shader parameters to keep the permutations simpler
3587 // these can NOT degrade! only use for simple stuff
3588 enum
3589 {
3590         SHADERSTATICPARM_SATURATION_REDCOMPENSATE = 0, ///< red compensation filter for saturation
3591         SHADERSTATICPARM_EXACTSPECULARMATH = 1, ///< (lightsource or deluxemapping) use exact reflection map for specular effects, as opposed to the usual OpenGL approximation
3592 };
3593 #define SHADERSTATICPARMS_COUNT 2
3594
3595 static const char *shaderstaticparmstrings_list[SHADERSTATICPARMS_COUNT];
3596 static int shaderstaticparms_count = 0;
3597
3598 static unsigned int r_compileshader_staticparms[(SHADERSTATICPARMS_COUNT + 0x1F) >> 5] = {0};
3599 #define R_COMPILESHADER_STATICPARM_ENABLE(p) r_compileshader_staticparms[(p) >> 5] |= (1 << ((p) & 0x1F))
3600 qboolean R_CompileShader_CheckStaticParms(void)
3601 {
3602         static int r_compileshader_staticparms_save[1];
3603         memcpy(r_compileshader_staticparms_save, r_compileshader_staticparms, sizeof(r_compileshader_staticparms));
3604         memset(r_compileshader_staticparms, 0, sizeof(r_compileshader_staticparms));
3605
3606         // detect all
3607         if (r_glsl_saturation_redcompensate.integer)
3608                 R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_SATURATION_REDCOMPENSATE);
3609         if(r_shadow_glossexact.integer)
3610                 R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_EXACTSPECULARMATH);
3611
3612         return memcmp(r_compileshader_staticparms, r_compileshader_staticparms_save, sizeof(r_compileshader_staticparms));
3613 }
3614
3615 #define R_COMPILESHADER_STATICPARM_EMIT(p, n) \
3616         if(r_compileshader_staticparms[(p) >> 5] & (1 << ((p) & 0x1F))) \
3617                 shaderstaticparmstrings_list[shaderstaticparms_count++] = "#define " n "\n"; \
3618         else \
3619                 shaderstaticparmstrings_list[shaderstaticparms_count++] = "\n"
3620 void R_CompileShader_AddStaticParms(unsigned int mode, unsigned int permutation)
3621 {
3622         shaderstaticparms_count = 0;
3623
3624         // emit all
3625         R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_SATURATION_REDCOMPENSATE, "SATURATION_REDCOMPENSATE");
3626         R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_EXACTSPECULARMATH, "USEEXACTSPECULARMATH");
3627 }
3628
3629
3630 /// information about each possible shader permutation
3631 r_glsl_permutation_t *r_glsl_permutationhash[SHADERMODE_COUNT][SHADERPERMUTATION_HASHSIZE];
3632 /// currently selected permutation
3633 r_glsl_permutation_t *r_glsl_permutation;
3634 /// storage for permutations linked in the hash table
3635 memexpandablearray_t r_glsl_permutationarray;
3636
3637 static r_glsl_permutation_t *R_GLSL_FindPermutation(unsigned int mode, unsigned int permutation)
3638 {
3639         //unsigned int hashdepth = 0;
3640         unsigned int hashindex = (permutation * 0x1021) & (SHADERPERMUTATION_HASHSIZE - 1);
3641         r_glsl_permutation_t *p;
3642         for (p = r_glsl_permutationhash[mode][hashindex];p;p = p->hashnext)
3643         {
3644                 if (p->mode == mode && p->permutation == permutation)
3645                 {
3646                         //if (hashdepth > 10)
3647                         //      Con_Printf("R_GLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
3648                         return p;
3649                 }
3650                 //hashdepth++;
3651         }
3652         p = (r_glsl_permutation_t*)Mem_ExpandableArray_AllocRecord(&r_glsl_permutationarray);
3653         p->mode = mode;
3654         p->permutation = permutation;
3655         p->hashnext = r_glsl_permutationhash[mode][hashindex];
3656         r_glsl_permutationhash[mode][hashindex] = p;
3657         //if (hashdepth > 10)
3658         //      Con_Printf("R_GLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
3659         return p;
3660 }
3661
3662 static char *R_GLSL_GetText(const char *filename, qboolean printfromdisknotice)
3663 {
3664         char *shaderstring;
3665         if (!filename || !filename[0])
3666                 return NULL;
3667         if (!strcmp(filename, "glsl/default.glsl"))
3668         {
3669                 if (!glslshaderstring)
3670                 {
3671                         glslshaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
3672                         if (glslshaderstring)
3673                                 Con_DPrintf("Loading shaders from file %s...\n", filename);
3674                         else
3675                                 glslshaderstring = (char *)builtinshaderstring;
3676                 }
3677                 shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(glslshaderstring) + 1);
3678                 memcpy(shaderstring, glslshaderstring, strlen(glslshaderstring) + 1);
3679                 return shaderstring;
3680         }
3681         shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
3682         if (shaderstring)
3683         {
3684                 if (printfromdisknotice)
3685                         Con_DPrintf("from disk %s... ", filename);
3686                 return shaderstring;
3687         }
3688         return shaderstring;
3689 }
3690
3691 static void R_GLSL_CompilePermutation(r_glsl_permutation_t *p, unsigned int mode, unsigned int permutation)
3692 {
3693         int i;
3694         shadermodeinfo_t *modeinfo = glslshadermodeinfo + mode;
3695         char *vertexstring, *geometrystring, *fragmentstring;
3696         char permutationname[256];
3697         int vertstrings_count = 0;
3698         int geomstrings_count = 0;
3699         int fragstrings_count = 0;
3700         const char *vertstrings_list[32+3+SHADERSTATICPARMS_COUNT+1];
3701         const char *geomstrings_list[32+3+SHADERSTATICPARMS_COUNT+1];
3702         const char *fragstrings_list[32+3+SHADERSTATICPARMS_COUNT+1];
3703
3704         if (p->compiled)
3705                 return;
3706         p->compiled = true;
3707         p->program = 0;
3708
3709         permutationname[0] = 0;
3710         vertexstring   = R_GLSL_GetText(modeinfo->vertexfilename, true);
3711         geometrystring = R_GLSL_GetText(modeinfo->geometryfilename, false);
3712         fragmentstring = R_GLSL_GetText(modeinfo->fragmentfilename, false);
3713
3714         strlcat(permutationname, modeinfo->vertexfilename, sizeof(permutationname));
3715
3716         // the first pretext is which type of shader to compile as
3717         // (later these will all be bound together as a program object)
3718         vertstrings_list[vertstrings_count++] = "#define VERTEX_SHADER\n";
3719         geomstrings_list[geomstrings_count++] = "#define GEOMETRY_SHADER\n";
3720         fragstrings_list[fragstrings_count++] = "#define FRAGMENT_SHADER\n";
3721
3722         // the second pretext is the mode (for example a light source)
3723         vertstrings_list[vertstrings_count++] = modeinfo->pretext;
3724         geomstrings_list[geomstrings_count++] = modeinfo->pretext;
3725         fragstrings_list[fragstrings_count++] = modeinfo->pretext;
3726         strlcat(permutationname, modeinfo->name, sizeof(permutationname));
3727
3728         // now add all the permutation pretexts
3729         for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
3730         {
3731                 if (permutation & (1<<i))
3732                 {
3733                         vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i].pretext;
3734                         geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i].pretext;
3735                         fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i].pretext;
3736                         strlcat(permutationname, shaderpermutationinfo[i].name, sizeof(permutationname));
3737                 }
3738                 else
3739                 {
3740                         // keep line numbers correct
3741                         vertstrings_list[vertstrings_count++] = "\n";
3742                         geomstrings_list[geomstrings_count++] = "\n";
3743                         fragstrings_list[fragstrings_count++] = "\n";
3744                 }
3745         }
3746
3747         // add static parms
3748         R_CompileShader_AddStaticParms(mode, permutation);
3749         memcpy(vertstrings_list + vertstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
3750         vertstrings_count += shaderstaticparms_count;
3751         memcpy(geomstrings_list + geomstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
3752         geomstrings_count += shaderstaticparms_count;
3753         memcpy(fragstrings_list + fragstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
3754         fragstrings_count += shaderstaticparms_count;
3755
3756         // now append the shader text itself
3757         vertstrings_list[vertstrings_count++] = vertexstring;
3758         geomstrings_list[geomstrings_count++] = geometrystring;
3759         fragstrings_list[fragstrings_count++] = fragmentstring;
3760
3761         // if any sources were NULL, clear the respective list
3762         if (!vertexstring)
3763                 vertstrings_count = 0;
3764         if (!geometrystring)
3765                 geomstrings_count = 0;
3766         if (!fragmentstring)
3767                 fragstrings_count = 0;
3768
3769         // compile the shader program
3770         if (vertstrings_count + geomstrings_count + fragstrings_count)
3771                 p->program = GL_Backend_CompileProgram(vertstrings_count, vertstrings_list, geomstrings_count, geomstrings_list, fragstrings_count, fragstrings_list);
3772         if (p->program)
3773         {
3774                 CHECKGLERROR
3775                 qglUseProgramObjectARB(p->program);CHECKGLERROR
3776                 // look up all the uniform variable names we care about, so we don't
3777                 // have to look them up every time we set them
3778
3779                 p->loc_Texture_First              = qglGetUniformLocationARB(p->program, "Texture_First");
3780                 p->loc_Texture_Second             = qglGetUniformLocationARB(p->program, "Texture_Second");
3781                 p->loc_Texture_GammaRamps         = qglGetUniformLocationARB(p->program, "Texture_GammaRamps");
3782                 p->loc_Texture_Normal             = qglGetUniformLocationARB(p->program, "Texture_Normal");
3783                 p->loc_Texture_Color              = qglGetUniformLocationARB(p->program, "Texture_Color");
3784                 p->loc_Texture_Gloss              = qglGetUniformLocationARB(p->program, "Texture_Gloss");
3785                 p->loc_Texture_Glow               = qglGetUniformLocationARB(p->program, "Texture_Glow");
3786                 p->loc_Texture_SecondaryNormal    = qglGetUniformLocationARB(p->program, "Texture_SecondaryNormal");
3787                 p->loc_Texture_SecondaryColor     = qglGetUniformLocationARB(p->program, "Texture_SecondaryColor");
3788                 p->loc_Texture_SecondaryGloss     = qglGetUniformLocationARB(p->program, "Texture_SecondaryGloss");
3789                 p->loc_Texture_SecondaryGlow      = qglGetUniformLocationARB(p->program, "Texture_SecondaryGlow");
3790                 p->loc_Texture_Pants              = qglGetUniformLocationARB(p->program, "Texture_Pants");
3791                 p->loc_Texture_Shirt              = qglGetUniformLocationARB(p->program, "Texture_Shirt");
3792                 p->loc_Texture_FogHeightTexture   = qglGetUniformLocationARB(p->program, "Texture_FogHeightTexture");
3793                 p->loc_Texture_FogMask            = qglGetUniformLocationARB(p->program, "Texture_FogMask");
3794                 p->loc_Texture_Lightmap           = qglGetUniformLocationARB(p->program, "Texture_Lightmap");
3795                 p->loc_Texture_Deluxemap          = qglGetUniformLocationARB(p->program, "Texture_Deluxemap");
3796                 p->loc_Texture_Attenuation        = qglGetUniformLocationARB(p->program, "Texture_Attenuation");
3797                 p->loc_Texture_Cube               = qglGetUniformLocationARB(p->program, "Texture_Cube");
3798                 p->loc_Texture_Refraction         = qglGetUniformLocationARB(p->program, "Texture_Refraction");
3799                 p->loc_Texture_Reflection         = qglGetUniformLocationARB(p->program, "Texture_Reflection");
3800                 p->loc_Texture_ShadowMap2D        = qglGetUniformLocationARB(p->program, "Texture_ShadowMap2D");
3801                 p->loc_Texture_CubeProjection     = qglGetUniformLocationARB(p->program, "Texture_CubeProjection");
3802                 p->loc_Texture_ScreenDepth        = qglGetUniformLocationARB(p->program, "Texture_ScreenDepth");
3803                 p->loc_Texture_ScreenNormalMap    = qglGetUniformLocationARB(p->program, "Texture_ScreenNormalMap");
3804                 p->loc_Texture_ScreenDiffuse      = qglGetUniformLocationARB(p->program, "Texture_ScreenDiffuse");
3805                 p->loc_Texture_ScreenSpecular     = qglGetUniformLocationARB(p->program, "Texture_ScreenSpecular");
3806                 p->loc_Texture_ReflectMask        = qglGetUniformLocationARB(p->program, "Texture_ReflectMask");
3807                 p->loc_Texture_ReflectCube        = qglGetUniformLocationARB(p->program, "Texture_ReflectCube");
3808                 p->loc_Alpha                      = qglGetUniformLocationARB(p->program, "Alpha");
3809                 p->loc_BloomBlur_Parameters       = qglGetUniformLocationARB(p->program, "BloomBlur_Parameters");
3810                 p->loc_ClientTime                 = qglGetUniformLocationARB(p->program, "ClientTime");
3811                 p->loc_Color_Ambient              = qglGetUniformLocationARB(p->program, "Color_Ambient");
3812                 p->loc_Color_Diffuse              = qglGetUniformLocationARB(p->program, "Color_Diffuse");
3813                 p->loc_Color_Specular             = qglGetUniformLocationARB(p->program, "Color_Specular");
3814                 p->loc_Color_Glow                 = qglGetUniformLocationARB(p->program, "Color_Glow");
3815                 p->loc_Color_Pants                = qglGetUniformLocationARB(p->program, "Color_Pants");
3816                 p->loc_Color_Shirt                = qglGetUniformLocationARB(p->program, "Color_Shirt");
3817                 p->loc_DeferredColor_Ambient      = qglGetUniformLocationARB(p->program, "DeferredColor_Ambient");
3818                 p->loc_DeferredColor_Diffuse      = qglGetUniformLocationARB(p->program, "DeferredColor_Diffuse");
3819                 p->loc_DeferredColor_Specular     = qglGetUniformLocationARB(p->program, "DeferredColor_Specular");
3820                 p->loc_DeferredMod_Diffuse        = qglGetUniformLocationARB(p->program, "DeferredMod_Diffuse");
3821                 p->loc_DeferredMod_Specular       = qglGetUniformLocationARB(p->program, "DeferredMod_Specular");
3822                 p->loc_DistortScaleRefractReflect = qglGetUniformLocationARB(p->program, "DistortScaleRefractReflect");
3823                 p->loc_EyePosition                = qglGetUniformLocationARB(p->program, "EyePosition");
3824                 p->loc_FogColor                   = qglGetUniformLocationARB(p->program, "FogColor");
3825                 p->loc_FogHeightFade              = qglGetUniformLocationARB(p->program, "FogHeightFade");
3826                 p->loc_FogPlane                   = qglGetUniformLocationARB(p->program, "FogPlane");
3827                 p->loc_FogPlaneViewDist           = qglGetUniformLocationARB(p->program, "FogPlaneViewDist");
3828                 p->loc_FogRangeRecip              = qglGetUniformLocationARB(p->program, "FogRangeRecip");
3829                 p->loc_LightColor                 = qglGetUniformLocationARB(p->program, "LightColor");
3830                 p->loc_LightDir                   = qglGetUniformLocationARB(p->program, "LightDir");
3831                 p->loc_LightPosition              = qglGetUniformLocationARB(p->program, "LightPosition");
3832                 p->loc_OffsetMapping_Scale        = qglGetUniformLocationARB(p->program, "OffsetMapping_Scale");
3833                 p->loc_PixelSize                  = qglGetUniformLocationARB(p->program, "PixelSize");
3834                 p->loc_ReflectColor               = qglGetUniformLocationARB(p->program, "ReflectColor");
3835                 p->loc_ReflectFactor              = qglGetUniformLocationARB(p->program, "ReflectFactor");
3836                 p->loc_ReflectOffset              = qglGetUniformLocationARB(p->program, "ReflectOffset");
3837                 p->loc_RefractColor               = qglGetUniformLocationARB(p->program, "RefractColor");
3838                 p->loc_Saturation                 = qglGetUniformLocationARB(p->program, "Saturation");
3839                 p->loc_ScreenCenterRefractReflect = qglGetUniformLocationARB(p->program, "ScreenCenterRefractReflect");
3840                 p->loc_ScreenScaleRefractReflect  = qglGetUniformLocationARB(p->program, "ScreenScaleRefractReflect");
3841                 p->loc_ScreenToDepth              = qglGetUniformLocationARB(p->program, "ScreenToDepth");
3842                 p->loc_ShadowMap_Parameters       = qglGetUniformLocationARB(p->program, "ShadowMap_Parameters");
3843                 p->loc_ShadowMap_TextureScale     = qglGetUniformLocationARB(p->program, "ShadowMap_TextureScale");
3844                 p->loc_SpecularPower              = qglGetUniformLocationARB(p->program, "SpecularPower");
3845                 p->loc_UserVec1                   = qglGetUniformLocationARB(p->program, "UserVec1");
3846                 p->loc_UserVec2                   = qglGetUniformLocationARB(p->program, "UserVec2");
3847                 p->loc_UserVec3                   = qglGetUniformLocationARB(p->program, "UserVec3");
3848                 p->loc_UserVec4                   = qglGetUniformLocationARB(p->program, "UserVec4");
3849                 p->loc_ViewTintColor              = qglGetUniformLocationARB(p->program, "ViewTintColor");
3850                 p->loc_ViewToLight                = qglGetUniformLocationARB(p->program, "ViewToLight");
3851                 p->loc_ModelToLight               = qglGetUniformLocationARB(p->program, "ModelToLight");
3852                 p->loc_TexMatrix                  = qglGetUniformLocationARB(p->program, "TexMatrix");
3853                 p->loc_BackgroundTexMatrix        = qglGetUniformLocationARB(p->program, "BackgroundTexMatrix");
3854                 p->loc_ModelViewMatrix            = qglGetUniformLocationARB(p->program, "ModelViewMatrix");
3855                 p->loc_ModelViewProjectionMatrix  = qglGetUniformLocationARB(p->program, "ModelViewProjectionMatrix");
3856                 p->loc_PixelToScreenTexCoord      = qglGetUniformLocationARB(p->program, "PixelToScreenTexCoord");
3857                 p->loc_ModelToReflectCube         = qglGetUniformLocationARB(p->program, "ModelToReflectCube");
3858                 p->loc_ShadowMapMatrix            = qglGetUniformLocationARB(p->program, "ShadowMapMatrix");
3859                 p->loc_BloomColorSubtract         = qglGetUniformLocationARB(p->program, "BloomColorSubtract");
3860                 p->loc_NormalmapScrollBlend       = qglGetUniformLocationARB(p->program, "NormalmapScrollBlend");
3861                 // initialize the samplers to refer to the texture units we use
3862                 if (p->loc_Texture_First           >= 0) qglUniform1iARB(p->loc_Texture_First          , GL20TU_FIRST);
3863                 if (p->loc_Texture_Second          >= 0) qglUniform1iARB(p->loc_Texture_Second         , GL20TU_SECOND);
3864                 if (p->loc_Texture_GammaRamps      >= 0) qglUniform1iARB(p->loc_Texture_GammaRamps     , GL20TU_GAMMARAMPS);
3865                 if (p->loc_Texture_Normal          >= 0) qglUniform1iARB(p->loc_Texture_Normal         , GL20TU_NORMAL);
3866                 if (p->loc_Texture_Color           >= 0) qglUniform1iARB(p->loc_Texture_Color          , GL20TU_COLOR);
3867                 if (p->loc_Texture_Gloss           >= 0) qglUniform1iARB(p->loc_Texture_Gloss          , GL20TU_GLOSS);
3868                 if (p->loc_Texture_Glow            >= 0) qglUniform1iARB(p->loc_Texture_Glow           , GL20TU_GLOW);
3869                 if (p->loc_Texture_SecondaryNormal >= 0) qglUniform1iARB(p->loc_Texture_SecondaryNormal, GL20TU_SECONDARY_NORMAL);
3870                 if (p->loc_Texture_SecondaryColor  >= 0) qglUniform1iARB(p->loc_Texture_SecondaryColor , GL20TU_SECONDARY_COLOR);
3871                 if (p->loc_Texture_SecondaryGloss  >= 0) qglUniform1iARB(p->loc_Texture_SecondaryGloss , GL20TU_SECONDARY_GLOSS);
3872                 if (p->loc_Texture_SecondaryGlow   >= 0) qglUniform1iARB(p->loc_Texture_SecondaryGlow  , GL20TU_SECONDARY_GLOW);
3873                 if (p->loc_Texture_Pants           >= 0) qglUniform1iARB(p->loc_Texture_Pants          , GL20TU_PANTS);
3874                 if (p->loc_Texture_Shirt           >= 0) qglUniform1iARB(p->loc_Texture_Shirt          , GL20TU_SHIRT);
3875                 if (p->loc_Texture_FogHeightTexture>= 0) qglUniform1iARB(p->loc_Texture_FogHeightTexture, GL20TU_FOGHEIGHTTEXTURE);
3876                 if (p->loc_Texture_FogMask         >= 0) qglUniform1iARB(p->loc_Texture_FogMask        , GL20TU_FOGMASK);
3877                 if (p->loc_Texture_Lightmap        >= 0) qglUniform1iARB(p->loc_Texture_Lightmap       , GL20TU_LIGHTMAP);
3878                 if (p->loc_Texture_Deluxemap       >= 0) qglUniform1iARB(p->loc_Texture_Deluxemap      , GL20TU_DELUXEMAP);
3879                 if (p->loc_Texture_Attenuation     >= 0) qglUniform1iARB(p->loc_Texture_Attenuation    , GL20TU_ATTENUATION);
3880                 if (p->loc_Texture_Cube            >= 0) qglUniform1iARB(p->loc_Texture_Cube           , GL20TU_CUBE);
3881                 if (p->loc_Texture_Refraction      >= 0) qglUniform1iARB(p->loc_Texture_Refraction     , GL20TU_REFRACTION);
3882                 if (p->loc_Texture_Reflection      >= 0) qglUniform1iARB(p->loc_Texture_Reflection     , GL20TU_REFLECTION);
3883                 if (p->loc_Texture_ShadowMap2D     >= 0) qglUniform1iARB(p->loc_Texture_ShadowMap2D    , GL20TU_SHADOWMAP2D);
3884                 if (p->loc_Texture_CubeProjection  >= 0) qglUniform1iARB(p->loc_Texture_CubeProjection , GL20TU_CUBEPROJECTION);
3885                 if (p->loc_Texture_ScreenDepth     >= 0) qglUniform1iARB(p->loc_Texture_ScreenDepth    , GL20TU_SCREENDEPTH);
3886                 if (p->loc_Texture_ScreenNormalMap >= 0) qglUniform1iARB(p->loc_Texture_ScreenNormalMap, GL20TU_SCREENNORMALMAP);
3887                 if (p->loc_Texture_ScreenDiffuse   >= 0) qglUniform1iARB(p->loc_Texture_ScreenDiffuse  , GL20TU_SCREENDIFFUSE);
3888                 if (p->loc_Texture_ScreenSpecular  >= 0) qglUniform1iARB(p->loc_Texture_ScreenSpecular , GL20TU_SCREENSPECULAR);
3889                 if (p->loc_Texture_ReflectMask     >= 0) qglUniform1iARB(p->loc_Texture_ReflectMask    , GL20TU_REFLECTMASK);
3890                 if (p->loc_Texture_ReflectCube     >= 0) qglUniform1iARB(p->loc_Texture_ReflectCube    , GL20TU_REFLECTCUBE);
3891                 CHECKGLERROR
3892                 Con_DPrintf("^5GLSL shader %s compiled.\n", permutationname);
3893         }
3894         else
3895                 Con_Printf("^1GLSL shader %s failed!  some features may not work properly.\n", permutationname);
3896
3897         // free the strings
3898         if (vertexstring)
3899                 Mem_Free(vertexstring);
3900         if (geometrystring)
3901                 Mem_Free(geometrystring);
3902         if (fragmentstring)
3903                 Mem_Free(fragmentstring);
3904 }
3905
3906 void R_SetupShader_SetPermutationGLSL(unsigned int mode, unsigned int permutation)
3907 {
3908         r_glsl_permutation_t *perm = R_GLSL_FindPermutation(mode, permutation);
3909         if (r_glsl_permutation != perm)
3910         {
3911                 r_glsl_permutation = perm;
3912                 if (!r_glsl_permutation->program)
3913                 {
3914                         if (!r_glsl_permutation->compiled)
3915                                 R_GLSL_CompilePermutation(perm, mode, permutation);
3916                         if (!r_glsl_permutation->program)
3917                         {
3918                                 // remove features until we find a valid permutation
3919                                 int i;
3920                                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
3921                                 {
3922                                         // reduce i more quickly whenever it would not remove any bits
3923                                         int j = 1<<(SHADERPERMUTATION_COUNT-1-i);
3924                                         if (!(permutation & j))
3925                                                 continue;
3926                                         permutation -= j;
3927                                         r_glsl_permutation = R_GLSL_FindPermutation(mode, permutation);
3928                                         if (!r_glsl_permutation->compiled)
3929                                                 R_GLSL_CompilePermutation(perm, mode, permutation);
3930                                         if (r_glsl_permutation->program)
3931                                                 break;
3932                                 }
3933                                 if (i >= SHADERPERMUTATION_COUNT)
3934                                 {
3935                                         //Con_Printf("Could not find a working OpenGL 2.0 shader for permutation %s %s\n", shadermodeinfo[mode].vertexfilename, shadermodeinfo[mode].pretext);
3936                                         r_glsl_permutation = R_GLSL_FindPermutation(mode, permutation);
3937                                         qglUseProgramObjectARB(0);CHECKGLERROR
3938                                         return; // no bit left to clear, entire mode is broken
3939                                 }
3940                         }
3941                 }
3942                 CHECKGLERROR
3943                 qglUseProgramObjectARB(r_glsl_permutation->program);CHECKGLERROR
3944         }
3945         if (r_glsl_permutation->loc_ModelViewProjectionMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewProjectionMatrix, 1, false, gl_modelviewprojection16f);
3946         if (r_glsl_permutation->loc_ModelViewMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewMatrix, 1, false, gl_modelview16f);
3947         if (r_glsl_permutation->loc_ClientTime >= 0) qglUniform1fARB(r_glsl_permutation->loc_ClientTime, cl.time);
3948 }
3949
3950 #ifdef SUPPORTCG
3951 #include <Cg/cgGL.h>
3952 struct r_cg_permutation_s;
3953 typedef struct r_cg_permutation_s
3954 {
3955         /// hash lookup data
3956         struct r_cg_permutation_s *hashnext;
3957         unsigned int mode;
3958         unsigned int permutation;
3959
3960         /// indicates if we have tried compiling this permutation already
3961         qboolean compiled;
3962         /// 0 if compilation failed
3963         CGprogram vprogram;
3964         CGprogram fprogram;
3965         /// locations of detected parameters in programs, or NULL if not found
3966         CGparameter vp_EyePosition;
3967         CGparameter vp_FogPlane;
3968         CGparameter vp_LightDir;
3969         CGparameter vp_LightPosition;
3970         CGparameter vp_ModelToLight;
3971         CGparameter vp_TexMatrix;
3972         CGparameter vp_BackgroundTexMatrix;
3973         CGparameter vp_ModelViewProjectionMatrix;
3974         CGparameter vp_ModelViewMatrix;
3975         CGparameter vp_ShadowMapMatrix;
3976
3977         CGparameter fp_Texture_First;
3978         CGparameter fp_Texture_Second;
3979         CGparameter fp_Texture_GammaRamps;
3980         CGparameter fp_Texture_Normal;
3981         CGparameter fp_Texture_Color;
3982         CGparameter fp_Texture_Gloss;
3983         CGparameter fp_Texture_Glow;
3984         CGparameter fp_Texture_SecondaryNormal;
3985         CGparameter fp_Texture_SecondaryColor;
3986         CGparameter fp_Texture_SecondaryGloss;
3987         CGparameter fp_Texture_SecondaryGlow;
3988         CGparameter fp_Texture_Pants;
3989         CGparameter fp_Texture_Shirt;
3990         CGparameter fp_Texture_FogHeightTexture;
3991         CGparameter fp_Texture_FogMask;
3992         CGparameter fp_Texture_Lightmap;
3993         CGparameter fp_Texture_Deluxemap;
3994         CGparameter fp_Texture_Attenuation;
3995         CGparameter fp_Texture_Cube;
3996         CGparameter fp_Texture_Refraction;
3997         CGparameter fp_Texture_Reflection;
3998         CGparameter fp_Texture_ShadowMap2D;
3999         CGparameter fp_Texture_CubeProjection;
4000         CGparameter fp_Texture_ScreenDepth;
4001         CGparameter fp_Texture_ScreenNormalMap;
4002         CGparameter fp_Texture_ScreenDiffuse;
4003         CGparameter fp_Texture_ScreenSpecular;
4004         CGparameter fp_Texture_ReflectMask;
4005         CGparameter fp_Texture_ReflectCube;
4006         CGparameter fp_Alpha;
4007         CGparameter fp_BloomBlur_Parameters;
4008         CGparameter fp_ClientTime;
4009         CGparameter fp_Color_Ambient;
4010         CGparameter fp_Color_Diffuse;
4011         CGparameter fp_Color_Specular;
4012         CGparameter fp_Color_Glow;
4013         CGparameter fp_Color_Pants;
4014         CGparameter fp_Color_Shirt;
4015         CGparameter fp_DeferredColor_Ambient;
4016         CGparameter fp_DeferredColor_Diffuse;
4017         CGparameter fp_DeferredColor_Specular;
4018         CGparameter fp_DeferredMod_Diffuse;
4019         CGparameter fp_DeferredMod_Specular;
4020         CGparameter fp_DistortScaleRefractReflect;
4021         CGparameter fp_EyePosition;
4022         CGparameter fp_FogColor;
4023         CGparameter fp_FogHeightFade;
4024         CGparameter fp_FogPlane;
4025         CGparameter fp_FogPlaneViewDist;
4026         CGparameter fp_FogRangeRecip;
4027         CGparameter fp_LightColor;
4028         CGparameter fp_LightDir;
4029         CGparameter fp_LightPosition;
4030         CGparameter fp_OffsetMapping_Scale;
4031         CGparameter fp_PixelSize;
4032         CGparameter fp_ReflectColor;
4033         CGparameter fp_ReflectFactor;
4034         CGparameter fp_ReflectOffset;
4035         CGparameter fp_RefractColor;
4036         CGparameter fp_Saturation;
4037         CGparameter fp_ScreenCenterRefractReflect;
4038         CGparameter fp_ScreenScaleRefractReflect;
4039         CGparameter fp_ScreenToDepth;
4040         CGparameter fp_ShadowMap_Parameters;
4041         CGparameter fp_ShadowMap_TextureScale;
4042         CGparameter fp_SpecularPower;
4043         CGparameter fp_UserVec1;
4044         CGparameter fp_UserVec2;
4045         CGparameter fp_UserVec3;
4046         CGparameter fp_UserVec4;
4047         CGparameter fp_ViewTintColor;
4048         CGparameter fp_ViewToLight;
4049         CGparameter fp_PixelToScreenTexCoord;
4050         CGparameter fp_ModelToReflectCube;
4051         CGparameter fp_BloomColorSubtract;
4052         CGparameter fp_NormalmapScrollBlend;
4053 }
4054 r_cg_permutation_t;
4055
4056 /// information about each possible shader permutation
4057 r_cg_permutation_t *r_cg_permutationhash[SHADERMODE_COUNT][SHADERPERMUTATION_HASHSIZE];
4058 /// currently selected permutation
4059 r_cg_permutation_t *r_cg_permutation;
4060 /// storage for permutations linked in the hash table
4061 memexpandablearray_t r_cg_permutationarray;
4062
4063 #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));}}
4064
4065 static r_cg_permutation_t *R_CG_FindPermutation(unsigned int mode, unsigned int permutation)
4066 {
4067         //unsigned int hashdepth = 0;
4068         unsigned int hashindex = (permutation * 0x1021) & (SHADERPERMUTATION_HASHSIZE - 1);
4069         r_cg_permutation_t *p;
4070         for (p = r_cg_permutationhash[mode][hashindex];p;p = p->hashnext)
4071         {
4072                 if (p->mode == mode && p->permutation == permutation)
4073                 {
4074                         //if (hashdepth > 10)
4075                         //      Con_Printf("R_CG_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
4076                         return p;
4077                 }
4078                 //hashdepth++;
4079         }
4080         p = (r_cg_permutation_t*)Mem_ExpandableArray_AllocRecord(&r_cg_permutationarray);
4081         p->mode = mode;
4082         p->permutation = permutation;
4083         p->hashnext = r_cg_permutationhash[mode][hashindex];
4084         r_cg_permutationhash[mode][hashindex] = p;
4085         //if (hashdepth > 10)
4086         //      Con_Printf("R_CG_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
4087         return p;
4088 }
4089
4090 static char *R_CG_GetText(const char *filename, qboolean printfromdisknotice)
4091 {
4092         char *shaderstring;
4093         if (!filename || !filename[0])
4094                 return NULL;
4095         if (!strcmp(filename, "cg/default.cg"))
4096         {
4097                 if (!cgshaderstring)
4098                 {
4099                         cgshaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
4100                         if (cgshaderstring)
4101                                 Con_DPrintf("Loading shaders from file %s...\n", filename);
4102                         else
4103                                 cgshaderstring = (char *)builtincgshaderstring;
4104                 }
4105                 shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(cgshaderstring) + 1);
4106                 memcpy(shaderstring, cgshaderstring, strlen(cgshaderstring) + 1);
4107                 return shaderstring;
4108         }
4109         shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
4110         if (shaderstring)
4111         {
4112                 if (printfromdisknotice)
4113                         Con_DPrintf("from disk %s... ", filename);
4114                 return shaderstring;
4115         }
4116         return shaderstring;
4117 }
4118
4119 static void R_CG_CacheShader(r_cg_permutation_t *p, const char *cachename, const char *vertstring, const char *fragstring)
4120 {
4121         // TODO: load or create .fp and .vp shader files
4122 }
4123
4124 static void R_CG_CompilePermutation(r_cg_permutation_t *p, unsigned int mode, unsigned int permutation)
4125 {
4126         int i;
4127         shadermodeinfo_t *modeinfo = cgshadermodeinfo + mode;
4128         int vertstring_length = 0;
4129         int geomstring_length = 0;
4130         int fragstring_length = 0;
4131         char *t;
4132         char *vertexstring, *geometrystring, *fragmentstring;
4133         char *vertstring, *geomstring, *fragstring;
4134         char permutationname[256];
4135         char cachename[256];
4136         CGprofile vertexProfile;
4137         CGprofile fragmentProfile;
4138         int vertstrings_count = 0;
4139         int geomstrings_count = 0;
4140         int fragstrings_count = 0;
4141         const char *vertstrings_list[32+3+SHADERSTATICPARMS_COUNT+1];
4142         const char *geomstrings_list[32+3+SHADERSTATICPARMS_COUNT+1];
4143         const char *fragstrings_list[32+3+SHADERSTATICPARMS_COUNT+1];
4144
4145         if (p->compiled)
4146                 return;
4147         p->compiled = true;
4148         p->vprogram = NULL;
4149         p->fprogram = NULL;
4150
4151         permutationname[0] = 0;
4152         cachename[0] = 0;
4153         vertexstring   = R_CG_GetText(modeinfo->vertexfilename, true);
4154         geometrystring = R_CG_GetText(modeinfo->geometryfilename, false);
4155         fragmentstring = R_CG_GetText(modeinfo->fragmentfilename, false);
4156
4157         strlcat(permutationname, modeinfo->vertexfilename, sizeof(permutationname));
4158         strlcat(cachename, "cg/", sizeof(cachename));
4159
4160         // the first pretext is which type of shader to compile as
4161         // (later these will all be bound together as a program object)
4162         vertstrings_list[vertstrings_count++] = "#define VERTEX_SHADER\n";
4163         geomstrings_list[geomstrings_count++] = "#define GEOMETRY_SHADER\n";
4164         fragstrings_list[fragstrings_count++] = "#define FRAGMENT_SHADER\n";
4165
4166         // the second pretext is the mode (for example a light source)
4167         vertstrings_list[vertstrings_count++] = modeinfo->pretext;
4168         geomstrings_list[geomstrings_count++] = modeinfo->pretext;
4169         fragstrings_list[fragstrings_count++] = modeinfo->pretext;
4170         strlcat(permutationname, modeinfo->name, sizeof(permutationname));
4171         strlcat(cachename, modeinfo->name, sizeof(cachename));
4172
4173         // now add all the permutation pretexts
4174         for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
4175         {
4176                 if (permutation & (1<<i))
4177                 {
4178                         vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i].pretext;
4179                         geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i].pretext;
4180                         fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i].pretext;
4181                         strlcat(permutationname, shaderpermutationinfo[i].name, sizeof(permutationname));
4182                         strlcat(cachename, shaderpermutationinfo[i].name, sizeof(cachename));
4183                 }
4184                 else
4185                 {
4186                         // keep line numbers correct
4187                         vertstrings_list[vertstrings_count++] = "\n";
4188                         geomstrings_list[geomstrings_count++] = "\n";
4189                         fragstrings_list[fragstrings_count++] = "\n";
4190                 }
4191         }
4192
4193         // add static parms
4194         R_CompileShader_AddStaticParms(mode, permutation);
4195         memcpy(vertstrings_list + vertstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
4196         vertstrings_count += shaderstaticparms_count;
4197         memcpy(geomstrings_list + geomstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
4198         geomstrings_count += shaderstaticparms_count;
4199         memcpy(fragstrings_list + fragstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
4200         fragstrings_count += shaderstaticparms_count;
4201
4202         // replace spaces in the cachename with _ characters
4203         for (i = 0;cachename[i];i++)
4204                 if (cachename[i] == ' ')
4205                         cachename[i] = '_';
4206
4207         // now append the shader text itself
4208         vertstrings_list[vertstrings_count++] = vertexstring;
4209         geomstrings_list[geomstrings_count++] = geometrystring;
4210         fragstrings_list[fragstrings_count++] = fragmentstring;
4211
4212         // if any sources were NULL, clear the respective list
4213         if (!vertexstring)
4214                 vertstrings_count = 0;
4215         if (!geometrystring)
4216                 geomstrings_count = 0;
4217         if (!fragmentstring)
4218                 fragstrings_count = 0;
4219
4220         vertstring_length = 0;
4221         for (i = 0;i < vertstrings_count;i++)
4222                 vertstring_length += strlen(vertstrings_list[i]);
4223         vertstring = t = Mem_Alloc(tempmempool, vertstring_length + 1);
4224         for (i = 0;i < vertstrings_count;t += strlen(vertstrings_list[i]), i++)
4225                 memcpy(t, vertstrings_list[i], strlen(vertstrings_list[i]));
4226
4227         geomstring_length = 0;
4228         for (i = 0;i < geomstrings_count;i++)
4229                 geomstring_length += strlen(geomstrings_list[i]);
4230         geomstring = t = Mem_Alloc(tempmempool, geomstring_length + 1);
4231         for (i = 0;i < geomstrings_count;t += strlen(geomstrings_list[i]), i++)
4232                 memcpy(t, geomstrings_list[i], strlen(geomstrings_list[i]));
4233
4234         fragstring_length = 0;
4235         for (i = 0;i < fragstrings_count;i++)
4236                 fragstring_length += strlen(fragstrings_list[i]);
4237         fragstring = t = Mem_Alloc(tempmempool, fragstring_length + 1);
4238         for (i = 0;i < fragstrings_count;t += strlen(fragstrings_list[i]), i++)
4239                 memcpy(t, fragstrings_list[i], strlen(fragstrings_list[i]));
4240
4241         CHECKGLERROR
4242         CHECKCGERROR
4243         //vertexProfile = CG_PROFILE_ARBVP1;
4244         //fragmentProfile = CG_PROFILE_ARBFP1;
4245         vertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX);CHECKCGERROR
4246         fragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);CHECKCGERROR
4247         //cgGLSetOptimalOptions(vertexProfile);CHECKCGERROR
4248         //cgGLSetOptimalOptions(fragmentProfile);CHECKCGERROR
4249         //cgSetAutoCompile(vid.cgcontext, CG_COMPILE_MANUAL);CHECKCGERROR
4250         CHECKGLERROR
4251
4252         // try to load the cached shader, or generate one
4253         R_CG_CacheShader(p, cachename, vertstring, fragstring);
4254
4255         // if caching failed, do a dynamic compile for now
4256         CHECKCGERROR
4257         if (vertstring[0] && !p->vprogram)
4258                 p->vprogram = cgCreateProgram(vid.cgcontext, CG_SOURCE, vertstring, vertexProfile, NULL, NULL);
4259         CHECKCGERROR
4260         if (fragstring[0] && !p->fprogram)
4261                 p->fprogram = cgCreateProgram(vid.cgcontext, CG_SOURCE, fragstring, fragmentProfile, NULL, NULL);
4262         CHECKCGERROR
4263
4264         // look up all the uniform variable names we care about, so we don't
4265         // have to look them up every time we set them
4266         if (p->vprogram)
4267         {
4268                 CHECKCGERROR
4269                 cgGLLoadProgram(p->vprogram);CHECKCGERROR CHECKGLERROR
4270                 cgGLEnableProfile(vertexProfile);CHECKCGERROR CHECKGLERROR
4271                 p->vp_EyePosition                = cgGetNamedParameter(p->vprogram, "EyePosition");
4272                 p->vp_FogPlane                   = cgGetNamedParameter(p->vprogram, "FogPlane");
4273                 p->vp_LightDir                   = cgGetNamedParameter(p->vprogram, "LightDir");
4274                 p->vp_LightPosition              = cgGetNamedParameter(p->vprogram, "LightPosition");
4275                 p->vp_ModelToLight               = cgGetNamedParameter(p->vprogram, "ModelToLight");
4276                 p->vp_TexMatrix                  = cgGetNamedParameter(p->vprogram, "TexMatrix");
4277                 p->vp_BackgroundTexMatrix        = cgGetNamedParameter(p->vprogram, "BackgroundTexMatrix");
4278                 p->vp_ModelViewProjectionMatrix  = cgGetNamedParameter(p->vprogram, "ModelViewProjectionMatrix");
4279                 p->vp_ModelViewMatrix            = cgGetNamedParameter(p->vprogram, "ModelViewMatrix");
4280                 p->vp_ShadowMapMatrix            = cgGetNamedParameter(p->vprogram, "ShadowMapMatrix");
4281                 CHECKCGERROR
4282         }
4283         if (p->fprogram)
4284         {
4285                 CHECKCGERROR
4286                 cgGLLoadProgram(p->fprogram);CHECKCGERROR CHECKGLERROR
4287                 cgGLEnableProfile(fragmentProfile);CHECKCGERROR CHECKGLERROR
4288                 p->fp_Texture_First              = cgGetNamedParameter(p->fprogram, "Texture_First");
4289                 p->fp_Texture_Second             = cgGetNamedParameter(p->fprogram, "Texture_Second");
4290                 p->fp_Texture_GammaRamps         = cgGetNamedParameter(p->fprogram, "Texture_GammaRamps");
4291                 p->fp_Texture_Normal             = cgGetNamedParameter(p->fprogram, "Texture_Normal");
4292                 p->fp_Texture_Color              = cgGetNamedParameter(p->fprogram, "Texture_Color");
4293                 p->fp_Texture_Gloss              = cgGetNamedParameter(p->fprogram, "Texture_Gloss");
4294                 p->fp_Texture_Glow               = cgGetNamedParameter(p->fprogram, "Texture_Glow");
4295                 p->fp_Texture_SecondaryNormal    = cgGetNamedParameter(p->fprogram, "Texture_SecondaryNormal");
4296                 p->fp_Texture_SecondaryColor     = cgGetNamedParameter(p->fprogram, "Texture_SecondaryColor");
4297                 p->fp_Texture_SecondaryGloss     = cgGetNamedParameter(p->fprogram, "Texture_SecondaryGloss");
4298                 p->fp_Texture_SecondaryGlow      = cgGetNamedParameter(p->fprogram, "Texture_SecondaryGlow");
4299                 p->fp_Texture_Pants              = cgGetNamedParameter(p->fprogram, "Texture_Pants");
4300                 p->fp_Texture_Shirt              = cgGetNamedParameter(p->fprogram, "Texture_Shirt");
4301                 p->fp_Texture_FogHeightTexture   = cgGetNamedParameter(p->fprogram, "Texture_FogHeightTexture");
4302                 p->fp_Texture_FogMask            = cgGetNamedParameter(p->fprogram, "Texture_FogMask");
4303                 p->fp_Texture_Lightmap           = cgGetNamedParameter(p->fprogram, "Texture_Lightmap");
4304                 p->fp_Texture_Deluxemap          = cgGetNamedParameter(p->fprogram, "Texture_Deluxemap");
4305                 p->fp_Texture_Attenuation        = cgGetNamedParameter(p->fprogram, "Texture_Attenuation");
4306                 p->fp_Texture_Cube               = cgGetNamedParameter(p->fprogram, "Texture_Cube");
4307                 p->fp_Texture_Refraction         = cgGetNamedParameter(p->fprogram, "Texture_Refraction");
4308                 p->fp_Texture_Reflection         = cgGetNamedParameter(p->fprogram, "Texture_Reflection");
4309                 p->fp_Texture_ShadowMap2D        = cgGetNamedParameter(p->fprogram, "Texture_ShadowMap2D");
4310                 p->fp_Texture_CubeProjection     = cgGetNamedParameter(p->fprogram, "Texture_CubeProjection");
4311                 p->fp_Texture_ScreenDepth        = cgGetNamedParameter(p->fprogram, "Texture_ScreenDepth");
4312                 p->fp_Texture_ScreenNormalMap    = cgGetNamedParameter(p->fprogram, "Texture_ScreenNormalMap");
4313                 p->fp_Texture_ScreenDiffuse      = cgGetNamedParameter(p->fprogram, "Texture_ScreenDiffuse");
4314                 p->fp_Texture_ScreenSpecular     = cgGetNamedParameter(p->fprogram, "Texture_ScreenSpecular");
4315                 p->fp_Texture_ReflectMask        = cgGetNamedParameter(p->fprogram, "Texture_ReflectMask");
4316                 p->fp_Texture_ReflectCube        = cgGetNamedParameter(p->fprogram, "Texture_ReflectCube");
4317                 p->fp_Alpha                      = cgGetNamedParameter(p->fprogram, "Alpha");
4318                 p->fp_BloomBlur_Parameters       = cgGetNamedParameter(p->fprogram, "BloomBlur_Parameters");
4319                 p->fp_ClientTime                 = cgGetNamedParameter(p->fprogram, "ClientTime");
4320                 p->fp_Color_Ambient              = cgGetNamedParameter(p->fprogram, "Color_Ambient");
4321                 p->fp_Color_Diffuse              = cgGetNamedParameter(p->fprogram, "Color_Diffuse");
4322                 p->fp_Color_Specular             = cgGetNamedParameter(p->fprogram, "Color_Specular");
4323                 p->fp_Color_Glow                 = cgGetNamedParameter(p->fprogram, "Color_Glow");
4324                 p->fp_Color_Pants                = cgGetNamedParameter(p->fprogram, "Color_Pants");
4325                 p->fp_Color_Shirt                = cgGetNamedParameter(p->fprogram, "Color_Shirt");
4326                 p->fp_DeferredColor_Ambient      = cgGetNamedParameter(p->fprogram, "DeferredColor_Ambient");
4327                 p->fp_DeferredColor_Diffuse      = cgGetNamedParameter(p->fprogram, "DeferredColor_Diffuse");
4328                 p->fp_DeferredColor_Specular     = cgGetNamedParameter(p->fprogram, "DeferredColor_Specular");
4329                 p->fp_DeferredMod_Diffuse        = cgGetNamedParameter(p->fprogram, "DeferredMod_Diffuse");
4330                 p->fp_DeferredMod_Specular       = cgGetNamedParameter(p->fprogram, "DeferredMod_Specular");
4331                 p->fp_DistortScaleRefractReflect = cgGetNamedParameter(p->fprogram, "DistortScaleRefractReflect");
4332                 p->fp_EyePosition                = cgGetNamedParameter(p->fprogram, "EyePosition");
4333                 p->fp_FogColor                   = cgGetNamedParameter(p->fprogram, "FogColor");
4334                 p->fp_FogHeightFade              = cgGetNamedParameter(p->fprogram, "FogHeightFade");
4335                 p->fp_FogPlane                   = cgGetNamedParameter(p->fprogram, "FogPlane");
4336                 p->fp_FogPlaneViewDist           = cgGetNamedParameter(p->fprogram, "FogPlaneViewDist");
4337                 p->fp_FogRangeRecip              = cgGetNamedParameter(p->fprogram, "FogRangeRecip");
4338                 p->fp_LightColor                 = cgGetNamedParameter(p->fprogram, "LightColor");
4339                 p->fp_LightDir                   = cgGetNamedParameter(p->fprogram, "LightDir");
4340                 p->fp_LightPosition              = cgGetNamedParameter(p->fprogram, "LightPosition");
4341                 p->fp_OffsetMapping_Scale        = cgGetNamedParameter(p->fprogram, "OffsetMapping_Scale");
4342                 p->fp_PixelSize                  = cgGetNamedParameter(p->fprogram, "PixelSize");
4343                 p->fp_ReflectColor               = cgGetNamedParameter(p->fprogram, "ReflectColor");
4344                 p->fp_ReflectFactor              = cgGetNamedParameter(p->fprogram, "ReflectFactor");
4345                 p->fp_ReflectOffset              = cgGetNamedParameter(p->fprogram, "ReflectOffset");
4346                 p->fp_RefractColor               = cgGetNamedParameter(p->fprogram, "RefractColor");
4347                 p->fp_Saturation                 = cgGetNamedParameter(p->fprogram, "Saturation");
4348                 p->fp_ScreenCenterRefractReflect = cgGetNamedParameter(p->fprogram, "ScreenCenterRefractReflect");
4349                 p->fp_ScreenScaleRefractReflect  = cgGetNamedParameter(p->fprogram, "ScreenScaleRefractReflect");
4350                 p->fp_ScreenToDepth              = cgGetNamedParameter(p->fprogram, "ScreenToDepth");
4351                 p->fp_ShadowMap_Parameters       = cgGetNamedParameter(p->fprogram, "ShadowMap_Parameters");
4352                 p->fp_ShadowMap_TextureScale     = cgGetNamedParameter(p->fprogram, "ShadowMap_TextureScale");
4353                 p->fp_SpecularPower              = cgGetNamedParameter(p->fprogram, "SpecularPower");
4354                 p->fp_UserVec1                   = cgGetNamedParameter(p->fprogram, "UserVec1");
4355                 p->fp_UserVec2                   = cgGetNamedParameter(p->fprogram, "UserVec2");
4356                 p->fp_UserVec3                   = cgGetNamedParameter(p->fprogram, "UserVec3");
4357                 p->fp_UserVec4                   = cgGetNamedParameter(p->fprogram, "UserVec4");
4358                 p->fp_ViewTintColor              = cgGetNamedParameter(p->fprogram, "ViewTintColor");
4359                 p->fp_ViewToLight                = cgGetNamedParameter(p->fprogram, "ViewToLight");
4360                 p->fp_PixelToScreenTexCoord      = cgGetNamedParameter(p->fprogram, "PixelToScreenTexCoord");
4361                 p->fp_ModelToReflectCube         = cgGetNamedParameter(p->fprogram, "ModelToReflectCube");
4362                 p->fp_BloomColorSubtract         = cgGetNamedParameter(p->fprogram, "BloomColorSubtract");
4363                 p->fp_NormalmapScrollBlend       = cgGetNamedParameter(p->fprogram, "NormalmapScrollBlend");
4364                 CHECKCGERROR
4365         }
4366
4367         if ((p->vprogram || !vertstring[0]) && (p->fprogram || !fragstring[0]))
4368                 Con_DPrintf("^5CG shader %s compiled.\n", permutationname);
4369         else
4370                 Con_Printf("^1CG shader %s failed!  some features may not work properly.\n", permutationname);
4371
4372         // free the strings
4373         if (vertstring)
4374                 Mem_Free(vertstring);
4375         if (geomstring)
4376                 Mem_Free(geomstring);
4377         if (fragstring)
4378                 Mem_Free(fragstring);
4379         if (vertexstring)
4380                 Mem_Free(vertexstring);
4381         if (geometrystring)
4382                 Mem_Free(geometrystring);
4383         if (fragmentstring)
4384                 Mem_Free(fragmentstring);
4385 }
4386
4387 void R_SetupShader_SetPermutationCG(unsigned int mode, unsigned int permutation)
4388 {
4389         r_cg_permutation_t *perm = R_CG_FindPermutation(mode, permutation);
4390         CHECKGLERROR
4391         CHECKCGERROR
4392         if (r_cg_permutation != perm)
4393         {
4394                 r_cg_permutation = perm;
4395                 if (!r_cg_permutation->vprogram && !r_cg_permutation->fprogram)
4396                 {
4397                         if (!r_cg_permutation->compiled)
4398                                 R_CG_CompilePermutation(perm, mode, permutation);
4399                         if (!r_cg_permutation->vprogram && !r_cg_permutation->fprogram)
4400                         {
4401                                 // remove features until we find a valid permutation
4402                                 int i;
4403                                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
4404                                 {
4405                                         // reduce i more quickly whenever it would not remove any bits
4406                                         int j = 1<<(SHADERPERMUTATION_COUNT-1-i);
4407                                         if (!(permutation & j))
4408                                                 continue;
4409                                         permutation -= j;
4410                                         r_cg_permutation = R_CG_FindPermutation(mode, permutation);
4411                                         if (!r_cg_permutation->compiled)
4412                                                 R_CG_CompilePermutation(perm, mode, permutation);
4413                                         if (r_cg_permutation->vprogram || r_cg_permutation->fprogram)
4414                                                 break;
4415                                 }
4416                                 if (i >= SHADERPERMUTATION_COUNT)
4417                                 {
4418                                         //Con_Printf("Could not find a working Cg shader for permutation %s %s\n", shadermodeinfo[mode].vertexfilename, shadermodeinfo[mode].pretext);
4419                                         r_cg_permutation = R_CG_FindPermutation(mode, permutation);
4420                                         return; // no bit left to clear, entire mode is broken
4421                                 }
4422                         }
4423                 }
4424                 CHECKGLERROR
4425                 CHECKCGERROR
4426                 if (r_cg_permutation->vprogram)
4427                 {
4428                         cgGLLoadProgram(r_cg_permutation->vprogram);CHECKCGERROR CHECKGLERROR
4429                         cgGLBindProgram(r_cg_permutation->vprogram);CHECKCGERROR CHECKGLERROR
4430                         cgGLEnableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
4431                 }
4432                 else
4433                 {
4434                         cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
4435                         cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
4436                 }
4437                 if (r_cg_permutation->fprogram)
4438                 {
4439                         cgGLLoadProgram(r_cg_permutation->fprogram);CHECKCGERROR CHECKGLERROR
4440                         cgGLBindProgram(r_cg_permutation->fprogram);CHECKCGERROR CHECKGLERROR
4441                         cgGLEnableProfile(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
4442                 }
4443                 else
4444                 {
4445                         cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
4446                         cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
4447                 }
4448         }
4449         CHECKCGERROR
4450         if (r_cg_permutation->vp_ModelViewProjectionMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewProjectionMatrix, gl_modelviewprojection16f);CHECKCGERROR
4451         if (r_cg_permutation->vp_ModelViewMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewMatrix, gl_modelview16f);CHECKCGERROR
4452         if (r_cg_permutation->fp_ClientTime) cgGLSetParameter1f(r_cg_permutation->fp_ClientTime, cl.time);CHECKCGERROR
4453 }
4454
4455 void CG_BindTexture(CGparameter param, rtexture_t *tex)
4456 {
4457         cgGLSetTextureParameter(param, R_GetTexture(tex));
4458         cgGLEnableTextureParameter(param);
4459 }
4460 #endif
4461
4462 #ifdef SUPPORTD3D
4463
4464 #ifdef SUPPORTD3D
4465 #include <d3d9.h>
4466 extern LPDIRECT3DDEVICE9 vid_d3d9dev;
4467 extern D3DCAPS9 vid_d3d9caps;
4468 #endif
4469
4470 struct r_hlsl_permutation_s;
4471 typedef struct r_hlsl_permutation_s
4472 {
4473         /// hash lookup data
4474         struct r_hlsl_permutation_s *hashnext;
4475         unsigned int mode;
4476         unsigned int permutation;
4477
4478         /// indicates if we have tried compiling this permutation already
4479         qboolean compiled;
4480         /// NULL if compilation failed
4481         IDirect3DVertexShader9 *vertexshader;
4482         IDirect3DPixelShader9 *pixelshader;
4483 }
4484 r_hlsl_permutation_t;
4485
4486 typedef enum D3DVSREGISTER_e
4487 {
4488         D3DVSREGISTER_TexMatrix = 0, // float4x4
4489         D3DVSREGISTER_BackgroundTexMatrix = 4, // float4x4
4490         D3DVSREGISTER_ModelViewProjectionMatrix = 8, // float4x4
4491         D3DVSREGISTER_ModelViewMatrix = 12, // float4x4
4492         D3DVSREGISTER_ShadowMapMatrix = 16, // float4x4
4493         D3DVSREGISTER_ModelToLight = 20, // float4x4
4494         D3DVSREGISTER_EyePosition = 24,
4495         D3DVSREGISTER_FogPlane = 25,
4496         D3DVSREGISTER_LightDir = 26,
4497         D3DVSREGISTER_LightPosition = 27,
4498 }
4499 D3DVSREGISTER_t;
4500
4501 typedef enum D3DPSREGISTER_e
4502 {
4503         D3DPSREGISTER_Alpha = 0,
4504         D3DPSREGISTER_BloomBlur_Parameters = 1,
4505         D3DPSREGISTER_ClientTime = 2,
4506         D3DPSREGISTER_Color_Ambient = 3,
4507         D3DPSREGISTER_Color_Diffuse = 4,
4508         D3DPSREGISTER_Color_Specular = 5,
4509         D3DPSREGISTER_Color_Glow = 6,
4510         D3DPSREGISTER_Color_Pants = 7,
4511         D3DPSREGISTER_Color_Shirt = 8,
4512         D3DPSREGISTER_DeferredColor_Ambient = 9,
4513         D3DPSREGISTER_DeferredColor_Diffuse = 10,
4514         D3DPSREGISTER_DeferredColor_Specular = 11,
4515         D3DPSREGISTER_DeferredMod_Diffuse = 12,
4516         D3DPSREGISTER_DeferredMod_Specular = 13,
4517         D3DPSREGISTER_DistortScaleRefractReflect = 14,
4518         D3DPSREGISTER_EyePosition = 15, // unused
4519         D3DPSREGISTER_FogColor = 16,
4520         D3DPSREGISTER_FogHeightFade = 17,
4521         D3DPSREGISTER_FogPlane = 18,
4522         D3DPSREGISTER_FogPlaneViewDist = 19,
4523         D3DPSREGISTER_FogRangeRecip = 20,
4524         D3DPSREGISTER_LightColor = 21,
4525         D3DPSREGISTER_LightDir = 22, // unused
4526         D3DPSREGISTER_LightPosition = 23,
4527         D3DPSREGISTER_OffsetMapping_Scale = 24,
4528         D3DPSREGISTER_PixelSize = 25,
4529         D3DPSREGISTER_ReflectColor = 26,
4530         D3DPSREGISTER_ReflectFactor = 27,
4531         D3DPSREGISTER_ReflectOffset = 28,
4532         D3DPSREGISTER_RefractColor = 29,
4533         D3DPSREGISTER_Saturation = 30,
4534         D3DPSREGISTER_ScreenCenterRefractReflect = 31,
4535         D3DPSREGISTER_ScreenScaleRefractReflect = 32,
4536         D3DPSREGISTER_ScreenToDepth = 33,
4537         D3DPSREGISTER_ShadowMap_Parameters = 34,
4538         D3DPSREGISTER_ShadowMap_TextureScale = 35,
4539         D3DPSREGISTER_SpecularPower = 36,
4540         D3DPSREGISTER_UserVec1 = 37,
4541         D3DPSREGISTER_UserVec2 = 38,
4542         D3DPSREGISTER_UserVec3 = 39,
4543         D3DPSREGISTER_UserVec4 = 40,
4544         D3DPSREGISTER_ViewTintColor = 41,
4545         D3DPSREGISTER_PixelToScreenTexCoord = 42,
4546         D3DPSREGISTER_BloomColorSubtract = 43,
4547         D3DPSREGISTER_ViewToLight = 44, // float4x4
4548         D3DPSREGISTER_ModelToReflectCube = 48, // float4x4
4549         D3DPSREGISTER_NormalmapScrollBlend = 52,
4550         // next at 53
4551 }
4552 D3DPSREGISTER_t;
4553
4554 /// information about each possible shader permutation
4555 r_hlsl_permutation_t *r_hlsl_permutationhash[SHADERMODE_COUNT][SHADERPERMUTATION_HASHSIZE];
4556 /// currently selected permutation
4557 r_hlsl_permutation_t *r_hlsl_permutation;
4558 /// storage for permutations linked in the hash table
4559 memexpandablearray_t r_hlsl_permutationarray;
4560
4561 static r_hlsl_permutation_t *R_HLSL_FindPermutation(unsigned int mode, unsigned int permutation)
4562 {
4563         //unsigned int hashdepth = 0;
4564         unsigned int hashindex = (permutation * 0x1021) & (SHADERPERMUTATION_HASHSIZE - 1);
4565         r_hlsl_permutation_t *p;
4566         for (p = r_hlsl_permutationhash[mode][hashindex];p;p = p->hashnext)
4567         {
4568                 if (p->mode == mode && p->permutation == permutation)
4569                 {
4570                         //if (hashdepth > 10)
4571                         //      Con_Printf("R_HLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
4572                         return p;
4573                 }
4574                 //hashdepth++;
4575         }
4576         p = (r_hlsl_permutation_t*)Mem_ExpandableArray_AllocRecord(&r_hlsl_permutationarray);
4577         p->mode = mode;
4578         p->permutation = permutation;
4579         p->hashnext = r_hlsl_permutationhash[mode][hashindex];
4580         r_hlsl_permutationhash[mode][hashindex] = p;
4581         //if (hashdepth > 10)
4582         //      Con_Printf("R_HLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
4583         return p;
4584 }
4585
4586 static char *R_HLSL_GetText(const char *filename, qboolean printfromdisknotice)
4587 {
4588         char *shaderstring;
4589         if (!filename || !filename[0])
4590                 return NULL;
4591         if (!strcmp(filename, "hlsl/default.hlsl"))
4592         {
4593                 if (!hlslshaderstring)
4594                 {
4595                         hlslshaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
4596                         if (hlslshaderstring)
4597                                 Con_DPrintf("Loading shaders from file %s...\n", filename);
4598                         else
4599                                 hlslshaderstring = (char *)builtincgshaderstring;
4600                 }
4601                 shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(hlslshaderstring) + 1);
4602                 memcpy(shaderstring, hlslshaderstring, strlen(hlslshaderstring) + 1);
4603                 return shaderstring;
4604         }
4605         shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
4606         if (shaderstring)
4607         {
4608                 if (printfromdisknotice)
4609                         Con_DPrintf("from disk %s... ", filename);
4610                 return shaderstring;
4611         }
4612         return shaderstring;
4613 }
4614
4615 #include <d3dx9.h>
4616 //#include <d3dx9shader.h>
4617 //#include <d3dx9mesh.h>
4618
4619 static void R_HLSL_CacheShader(r_hlsl_permutation_t *p, const char *cachename, const char *vertstring, const char *fragstring)
4620 {
4621         DWORD *vsbin = NULL;
4622         DWORD *psbin = NULL;
4623         fs_offset_t vsbinsize;
4624         fs_offset_t psbinsize;
4625 //      IDirect3DVertexShader9 *vs = NULL;
4626 //      IDirect3DPixelShader9 *ps = NULL;
4627         ID3DXBuffer *vslog = NULL;
4628         ID3DXBuffer *vsbuffer = NULL;
4629         ID3DXConstantTable *vsconstanttable = NULL;
4630         ID3DXBuffer *pslog = NULL;
4631         ID3DXBuffer *psbuffer = NULL;
4632         ID3DXConstantTable *psconstanttable = NULL;
4633         int vsresult = 0;
4634         int psresult = 0;
4635         char temp[MAX_INPUTLINE];
4636         const char *vsversion = "vs_3_0", *psversion = "ps_3_0";
4637         qboolean debugshader = gl_paranoid.integer != 0;
4638         if (p->permutation & SHADERPERMUTATION_OFFSETMAPPING) {vsversion = "vs_3_0";psversion = "ps_3_0";}
4639         if (p->permutation & SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING) {vsversion = "vs_3_0";psversion = "ps_3_0";}
4640         if (!debugshader)
4641         {
4642                 vsbin = (DWORD *)FS_LoadFile(va("%s.vsbin", cachename), r_main_mempool, true, &vsbinsize);
4643                 psbin = (DWORD *)FS_LoadFile(va("%s.psbin", cachename), r_main_mempool, true, &psbinsize);
4644         }
4645         if ((!vsbin && vertstring) || (!psbin && fragstring))
4646         {
4647                 const char* dllnames_d3dx9 [] =
4648                 {
4649                         "d3dx9_43.dll",
4650                         "d3dx9_42.dll",
4651                         "d3dx9_41.dll",
4652                         "d3dx9_40.dll",
4653                         "d3dx9_39.dll",
4654                         "d3dx9_38.dll",
4655                         "d3dx9_37.dll",
4656                         "d3dx9_36.dll",
4657                         "d3dx9_35.dll",
4658                         "d3dx9_34.dll",
4659                         "d3dx9_33.dll",
4660                         "d3dx9_32.dll",
4661                         "d3dx9_31.dll",
4662                         "d3dx9_30.dll",
4663                         "d3dx9_29.dll",
4664                         "d3dx9_28.dll",
4665                         "d3dx9_27.dll",
4666                         "d3dx9_26.dll",
4667                         "d3dx9_25.dll",
4668                         "d3dx9_24.dll",
4669                         NULL
4670                 };
4671                 dllhandle_t d3dx9_dll = NULL;
4672                 HRESULT (WINAPI *qD3DXCompileShaderFromFileA)(LPCSTR pSrcFile, CONST D3DXMACRO* pDefines, LPD3DXINCLUDE pInclude, LPCSTR pFunctionName, LPCSTR pProfile, DWORD Flags, LPD3DXBUFFER* ppShader, LPD3DXBUFFER* ppErrorMsgs, LPD3DXCONSTANTTABLE* ppConstantTable);
4673                 HRESULT (WINAPI *qD3DXPreprocessShader)(LPCSTR pSrcData, UINT SrcDataSize, CONST D3DXMACRO* pDefines, LPD3DXINCLUDE pInclude, LPD3DXBUFFER* ppShaderText, LPD3DXBUFFER* ppErrorMsgs);
4674                 HRESULT (WINAPI *qD3DXCompileShader)(LPCSTR pSrcData, UINT SrcDataLen, CONST D3DXMACRO* pDefines, LPD3DXINCLUDE pInclude, LPCSTR pFunctionName, LPCSTR pProfile, DWORD Flags, LPD3DXBUFFER* ppShader, LPD3DXBUFFER* ppErrorMsgs, LPD3DXCONSTANTTABLE* ppConstantTable);
4675                 dllfunction_t d3dx9_dllfuncs[] =
4676                 {
4677                         {"D3DXCompileShaderFromFileA",  (void **) &qD3DXCompileShaderFromFileA},
4678                         {"D3DXPreprocessShader",                (void **) &qD3DXPreprocessShader},
4679                         {"D3DXCompileShader",                   (void **) &qD3DXCompileShader},
4680                         {NULL, NULL}
4681                 };
4682                 if (Sys_LoadLibrary(dllnames_d3dx9, &d3dx9_dll, d3dx9_dllfuncs))
4683                 {
4684                         DWORD shaderflags = 0;
4685                         if (debugshader)
4686                                 shaderflags = D3DXSHADER_DEBUG | D3DXSHADER_SKIPOPTIMIZATION;
4687                         vsbin = (DWORD *)Mem_Realloc(tempmempool, vsbin, 0);
4688                         psbin = (DWORD *)Mem_Realloc(tempmempool, psbin, 0);
4689                         if (vertstring && vertstring[0])
4690                         {
4691                                 if (debugshader)
4692                                 {
4693 //                                      vsresult = qD3DXPreprocessShader(vertstring, strlen(vertstring), NULL, NULL, &vsbuffer, &vslog);
4694 //                                      FS_WriteFile(va("%s_vs.fx", cachename), vsbuffer->GetBufferPointer(), vsbuffer->GetBufferSize());
4695                                         FS_WriteFile(va("%s_vs.fx", cachename), vertstring, strlen(vertstring));
4696                                         vsresult = qD3DXCompileShaderFromFileA(va("%s/%s_vs.fx", fs_gamedir, cachename), NULL, NULL, "main", vsversion, shaderflags, &vsbuffer, &vslog, &vsconstanttable);
4697                                 }
4698                                 else
4699                                         vsresult = qD3DXCompileShader(vertstring, strlen(vertstring), NULL, NULL, "main", vsversion, shaderflags, &vsbuffer, &vslog, &vsconstanttable);
4700                                 if (vsbuffer)
4701                                 {
4702                                         vsbinsize = vsbuffer->GetBufferSize();
4703                                         vsbin = (DWORD *)Mem_Alloc(tempmempool, vsbinsize);
4704                                         memcpy(vsbin, vsbuffer->GetBufferPointer(), vsbinsize);
4705                                         vsbuffer->Release();
4706                                 }
4707                                 if (vslog)
4708                                 {
4709                                         strlcpy(temp, (const char *)vslog->GetBufferPointer(), min(sizeof(temp), vslog->GetBufferSize()));
4710                                         Con_Printf("HLSL vertex shader compile output for %s follows:\n%s\n", cachename, temp);
4711                                         vslog->Release();
4712                                 }
4713                         }
4714                         if (fragstring && fragstring[0])
4715                         {
4716                                 if (debugshader)
4717                                 {
4718 //                                      psresult = qD3DXPreprocessShader(fragstring, strlen(fragstring), NULL, NULL, &psbuffer, &pslog);
4719 //                                      FS_WriteFile(va("%s_ps.fx", cachename), psbuffer->GetBufferPointer(), psbuffer->GetBufferSize());
4720                                         FS_WriteFile(va("%s_ps.fx", cachename), fragstring, strlen(fragstring));
4721                                         psresult = qD3DXCompileShaderFromFileA(va("%s/%s_ps.fx", fs_gamedir, cachename), NULL, NULL, "main", psversion, shaderflags, &psbuffer, &pslog, &psconstanttable);
4722                                 }
4723                                 else
4724                                         psresult = qD3DXCompileShader(fragstring, strlen(fragstring), NULL, NULL, "main", psversion, shaderflags, &psbuffer, &pslog, &psconstanttable);
4725                                 if (psbuffer)
4726                                 {
4727                                         psbinsize = psbuffer->GetBufferSize();
4728                                         psbin = (DWORD *)Mem_Alloc(tempmempool, psbinsize);
4729                                         memcpy(psbin, psbuffer->GetBufferPointer(), psbinsize);
4730                                         psbuffer->Release();
4731                                 }
4732                                 if (pslog)
4733                                 {
4734                                         strlcpy(temp, (const char *)pslog->GetBufferPointer(), min(sizeof(temp), pslog->GetBufferSize()));
4735                                         Con_Printf("HLSL pixel shader compile output for %s follows:\n%s\n", cachename, temp);
4736                                         pslog->Release();
4737                                 }
4738                         }
4739                         Sys_UnloadLibrary(&d3dx9_dll);
4740                 }
4741                 else
4742                         Con_Printf("Unable to compile shader - D3DXCompileShader function not found\n");
4743         }
4744         if (vsbin && psbin)
4745         {
4746                 vsresult = IDirect3DDevice9_CreateVertexShader(vid_d3d9dev, vsbin, &p->vertexshader);
4747                 if (FAILED(vsresult))
4748                         Con_Printf("HLSL CreateVertexShader failed for %s (hresult = %8x)\n", cachename, vsresult);
4749                 psresult = IDirect3DDevice9_CreatePixelShader(vid_d3d9dev, psbin, &p->pixelshader);
4750                 if (FAILED(psresult))
4751                         Con_Printf("HLSL CreatePixelShader failed for %s (hresult = %8x)\n", cachename, psresult);
4752         }
4753         // free the shader data
4754         vsbin = (DWORD *)Mem_Realloc(tempmempool, vsbin, 0);
4755         psbin = (DWORD *)Mem_Realloc(tempmempool, psbin, 0);
4756 }
4757
4758 static void R_HLSL_CompilePermutation(r_hlsl_permutation_t *p, unsigned int mode, unsigned int permutation)
4759 {
4760         int i;
4761         shadermodeinfo_t *modeinfo = hlslshadermodeinfo + mode;
4762         int vertstring_length = 0;
4763         int geomstring_length = 0;
4764         int fragstring_length = 0;
4765         char *t;
4766         char *vertexstring, *geometrystring, *fragmentstring;
4767         char *vertstring, *geomstring, *fragstring;
4768         char permutationname[256];
4769         char cachename[256];
4770         int vertstrings_count = 0;
4771         int geomstrings_count = 0;
4772         int fragstrings_count = 0;
4773         const char *vertstrings_list[32+3+SHADERSTATICPARMS_COUNT+1];
4774         const char *geomstrings_list[32+3+SHADERSTATICPARMS_COUNT+1];
4775         const char *fragstrings_list[32+3+SHADERSTATICPARMS_COUNT+1];
4776
4777         if (p->compiled)
4778                 return;
4779         p->compiled = true;
4780         p->vertexshader = NULL;
4781         p->pixelshader = NULL;
4782
4783         permutationname[0] = 0;
4784         cachename[0] = 0;
4785         vertexstring   = R_HLSL_GetText(modeinfo->vertexfilename, true);
4786         geometrystring = R_HLSL_GetText(modeinfo->geometryfilename, false);
4787         fragmentstring = R_HLSL_GetText(modeinfo->fragmentfilename, false);
4788
4789         strlcat(permutationname, modeinfo->vertexfilename, sizeof(permutationname));
4790         strlcat(cachename, "hlsl/", sizeof(cachename));
4791
4792         // define HLSL so that the shader can tell apart the HLSL compiler and the Cg compiler
4793         vertstrings_count = 0;
4794         geomstrings_count = 0;
4795         fragstrings_count = 0;
4796         vertstrings_list[vertstrings_count++] = "#define HLSL\n";
4797         geomstrings_list[geomstrings_count++] = "#define HLSL\n";
4798         fragstrings_list[fragstrings_count++] = "#define HLSL\n";
4799
4800         // the first pretext is which type of shader to compile as
4801         // (later these will all be bound together as a program object)
4802         vertstrings_list[vertstrings_count++] = "#define VERTEX_SHADER\n";
4803         geomstrings_list[geomstrings_count++] = "#define GEOMETRY_SHADER\n";
4804         fragstrings_list[fragstrings_count++] = "#define FRAGMENT_SHADER\n";
4805
4806         // the second pretext is the mode (for example a light source)
4807         vertstrings_list[vertstrings_count++] = modeinfo->pretext;
4808         geomstrings_list[geomstrings_count++] = modeinfo->pretext;
4809         fragstrings_list[fragstrings_count++] = modeinfo->pretext;
4810         strlcat(permutationname, modeinfo->name, sizeof(permutationname));
4811         strlcat(cachename, modeinfo->name, sizeof(cachename));
4812
4813         // now add all the permutation pretexts
4814         for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
4815         {
4816                 if (permutation & (1<<i))
4817                 {
4818                         vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i].pretext;
4819                         geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i].pretext;
4820                         fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i].pretext;
4821                         strlcat(permutationname, shaderpermutationinfo[i].name, sizeof(permutationname));
4822                         strlcat(cachename, shaderpermutationinfo[i].name, sizeof(cachename));
4823                 }
4824                 else
4825                 {
4826                         // keep line numbers correct
4827                         vertstrings_list[vertstrings_count++] = "\n";
4828                         geomstrings_list[geomstrings_count++] = "\n";
4829                         fragstrings_list[fragstrings_count++] = "\n";
4830                 }
4831         }
4832
4833         // add static parms
4834         R_CompileShader_AddStaticParms(mode, permutation);
4835         memcpy(vertstrings_list + vertstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
4836         vertstrings_count += shaderstaticparms_count;
4837         memcpy(geomstrings_list + geomstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
4838         geomstrings_count += shaderstaticparms_count;
4839         memcpy(fragstrings_list + fragstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
4840         fragstrings_count += shaderstaticparms_count;
4841
4842         // replace spaces in the cachename with _ characters
4843         for (i = 0;cachename[i];i++)
4844                 if (cachename[i] == ' ')
4845                         cachename[i] = '_';
4846
4847         // now append the shader text itself
4848         vertstrings_list[vertstrings_count++] = vertexstring;
4849         geomstrings_list[geomstrings_count++] = geometrystring;
4850         fragstrings_list[fragstrings_count++] = fragmentstring;
4851
4852         // if any sources were NULL, clear the respective list
4853         if (!vertexstring)
4854                 vertstrings_count = 0;
4855         if (!geometrystring)
4856                 geomstrings_count = 0;
4857         if (!fragmentstring)
4858                 fragstrings_count = 0;
4859
4860         vertstring_length = 0;
4861         for (i = 0;i < vertstrings_count;i++)
4862                 vertstring_length += strlen(vertstrings_list[i]);
4863         vertstring = t = (char *)Mem_Alloc(tempmempool, vertstring_length + 1);
4864         for (i = 0;i < vertstrings_count;t += strlen(vertstrings_list[i]), i++)
4865                 memcpy(t, vertstrings_list[i], strlen(vertstrings_list[i]));
4866
4867         geomstring_length = 0;
4868         for (i = 0;i < geomstrings_count;i++)
4869                 geomstring_length += strlen(geomstrings_list[i]);
4870         geomstring = t = (char *)Mem_Alloc(tempmempool, geomstring_length + 1);
4871         for (i = 0;i < geomstrings_count;t += strlen(geomstrings_list[i]), i++)
4872                 memcpy(t, geomstrings_list[i], strlen(geomstrings_list[i]));
4873
4874         fragstring_length = 0;
4875         for (i = 0;i < fragstrings_count;i++)
4876                 fragstring_length += strlen(fragstrings_list[i]);
4877         fragstring = t = (char *)Mem_Alloc(tempmempool, fragstring_length + 1);
4878         for (i = 0;i < fragstrings_count;t += strlen(fragstrings_list[i]), i++)
4879                 memcpy(t, fragstrings_list[i], strlen(fragstrings_list[i]));
4880
4881         // try to load the cached shader, or generate one
4882         R_HLSL_CacheShader(p, cachename, vertstring, fragstring);
4883
4884         if ((p->vertexshader || !vertstring[0]) && (p->pixelshader || !fragstring[0]))
4885                 Con_DPrintf("^5HLSL shader %s compiled.\n", permutationname);
4886         else
4887                 Con_Printf("^1HLSL shader %s failed!  some features may not work properly.\n", permutationname);
4888
4889         // free the strings
4890         if (vertstring)
4891                 Mem_Free(vertstring);
4892         if (geomstring)
4893                 Mem_Free(geomstring);
4894         if (fragstring)
4895                 Mem_Free(fragstring);
4896         if (vertexstring)
4897                 Mem_Free(vertexstring);
4898         if (geometrystring)
4899                 Mem_Free(geometrystring);
4900         if (fragmentstring)
4901                 Mem_Free(fragmentstring);
4902 }
4903
4904 static inline void hlslVSSetParameter16f(D3DVSREGISTER_t r, const float *a) {IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, a, 4);}
4905 static inline void hlslVSSetParameter4fv(D3DVSREGISTER_t r, const float *a) {IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, a, 1);}
4906 static inline void hlslVSSetParameter4f(D3DVSREGISTER_t r, float x, float y, float z, float w) {float temp[4];Vector4Set(temp, x, y, z, w);IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, temp, 1);}
4907 static inline void hlslVSSetParameter3f(D3DVSREGISTER_t r, float x, float y, float z) {float temp[4];Vector4Set(temp, x, y, z, 0);IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, temp, 1);}
4908 static inline void hlslVSSetParameter2f(D3DVSREGISTER_t r, float x, float y) {float temp[4];Vector4Set(temp, x, y, 0, 0);IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, temp, 1);}
4909 static inline void hlslVSSetParameter1f(D3DVSREGISTER_t r, float x) {float temp[4];Vector4Set(temp, x, 0, 0, 0);IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, temp, 1);}
4910
4911 static inline void hlslPSSetParameter16f(D3DPSREGISTER_t r, const float *a) {IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, a, 4);}
4912 static inline void hlslPSSetParameter4fv(D3DPSREGISTER_t r, const float *a) {IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, a, 1);}
4913 static inline void hlslPSSetParameter4f(D3DPSREGISTER_t r, float x, float y, float z, float w) {float temp[4];Vector4Set(temp, x, y, z, w);IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, temp, 1);}
4914 static inline void hlslPSSetParameter3f(D3DPSREGISTER_t r, float x, float y, float z) {float temp[4];Vector4Set(temp, x, y, z, 0);IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, temp, 1);}
4915 static inline void hlslPSSetParameter2f(D3DPSREGISTER_t r, float x, float y) {float temp[4];Vector4Set(temp, x, y, 0, 0);IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, temp, 1);}
4916 static inline void hlslPSSetParameter1f(D3DPSREGISTER_t r, float x) {float temp[4];Vector4Set(temp, x, 0, 0, 0);IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, temp, 1);}
4917
4918 void R_SetupShader_SetPermutationHLSL(unsigned int mode, unsigned int permutation)
4919 {
4920         r_hlsl_permutation_t *perm = R_HLSL_FindPermutation(mode, permutation);
4921         if (r_hlsl_permutation != perm)
4922         {
4923                 r_hlsl_permutation = perm;
4924                 if (!r_hlsl_permutation->vertexshader && !r_hlsl_permutation->pixelshader)
4925                 {
4926                         if (!r_hlsl_permutation->compiled)
4927                                 R_HLSL_CompilePermutation(perm, mode, permutation);
4928                         if (!r_hlsl_permutation->vertexshader && !r_hlsl_permutation->pixelshader)
4929                         {
4930                                 // remove features until we find a valid permutation
4931                                 int i;
4932                                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
4933                                 {
4934                                         // reduce i more quickly whenever it would not remove any bits
4935                                         int j = 1<<(SHADERPERMUTATION_COUNT-1-i);
4936                                         if (!(permutation & j))
4937                                                 continue;
4938                                         permutation -= j;
4939                                         r_hlsl_permutation = R_HLSL_FindPermutation(mode, permutation);
4940                                         if (!r_hlsl_permutation->compiled)
4941                                                 R_HLSL_CompilePermutation(perm, mode, permutation);
4942                                         if (r_hlsl_permutation->vertexshader || r_hlsl_permutation->pixelshader)
4943                                                 break;
4944                                 }
4945                                 if (i >= SHADERPERMUTATION_COUNT)
4946                                 {
4947                                         //Con_Printf("Could not find a working Cg shader for permutation %s %s\n", shadermodeinfo[mode].vertexfilename, shadermodeinfo[mode].pretext);
4948                                         r_hlsl_permutation = R_HLSL_FindPermutation(mode, permutation);
4949                                         return; // no bit left to clear, entire mode is broken
4950                                 }
4951                         }
4952                 }
4953                 IDirect3DDevice9_SetVertexShader(vid_d3d9dev, r_hlsl_permutation->vertexshader);
4954                 IDirect3DDevice9_SetPixelShader(vid_d3d9dev, r_hlsl_permutation->pixelshader);
4955         }
4956         hlslVSSetParameter16f(D3DVSREGISTER_ModelViewProjectionMatrix, gl_modelviewprojection16f);
4957         hlslVSSetParameter16f(D3DVSREGISTER_ModelViewMatrix, gl_modelview16f);
4958         hlslPSSetParameter1f(D3DPSREGISTER_ClientTime, cl.time);
4959 }
4960 #endif
4961
4962 void R_GLSL_Restart_f(void)
4963 {
4964         unsigned int i, limit;
4965         if (glslshaderstring && glslshaderstring != builtinshaderstring)
4966                 Mem_Free(glslshaderstring);
4967         glslshaderstring = NULL;
4968         if (cgshaderstring && cgshaderstring != builtincgshaderstring)
4969                 Mem_Free(cgshaderstring);
4970         cgshaderstring = NULL;
4971         if (hlslshaderstring && hlslshaderstring != builtincgshaderstring)
4972                 Mem_Free(hlslshaderstring);
4973         hlslshaderstring = NULL;
4974         switch(vid.renderpath)
4975         {
4976         case RENDERPATH_D3D9:
4977 #ifdef SUPPORTD3D
4978                 {
4979                         r_hlsl_permutation_t *p;
4980                         r_hlsl_permutation = NULL;
4981 //                      cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
4982 //                      cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
4983 //                      cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
4984 //                      cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
4985                         limit = Mem_ExpandableArray_IndexRange(&r_hlsl_permutationarray);
4986                         for (i = 0;i < limit;i++)
4987                         {
4988                                 if ((p = (r_hlsl_permutation_t*)Mem_ExpandableArray_RecordAtIndex(&r_hlsl_permutationarray, i)))
4989                                 {
4990                                         if (p->vertexshader)
4991                                                 IDirect3DVertexShader9_Release(p->vertexshader);
4992                                         if (p->pixelshader)
4993                                                 IDirect3DPixelShader9_Release(p->pixelshader);
4994                                         Mem_ExpandableArray_FreeRecord(&r_hlsl_permutationarray, (void*)p);
4995                                 }
4996                         }
4997                         memset(r_hlsl_permutationhash, 0, sizeof(r_hlsl_permutationhash));
4998                 }
4999 #endif
5000                 break;
5001         case RENDERPATH_D3D10:
5002                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5003                 break;
5004         case RENDERPATH_D3D11:
5005                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5006                 break;
5007         case RENDERPATH_GL20:
5008                 {
5009                         r_glsl_permutation_t *p;
5010                         r_glsl_permutation = NULL;
5011                         limit = Mem_ExpandableArray_IndexRange(&r_glsl_permutationarray);
5012                         for (i = 0;i < limit;i++)
5013                         {
5014                                 if ((p = (r_glsl_permutation_t*)Mem_ExpandableArray_RecordAtIndex(&r_glsl_permutationarray, i)))
5015                                 {
5016                                         GL_Backend_FreeProgram(p->program);
5017                                         Mem_ExpandableArray_FreeRecord(&r_glsl_permutationarray, (void*)p);
5018                                 }
5019                         }
5020                         memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash));
5021                 }
5022                 break;
5023         case RENDERPATH_CGGL:
5024 #ifdef SUPPORTCG
5025                 {
5026                         r_cg_permutation_t *p;
5027                         r_cg_permutation = NULL;
5028                         cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
5029                         cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
5030                         cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
5031                         cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
5032                         limit = Mem_ExpandableArray_IndexRange(&r_cg_permutationarray);
5033                         for (i = 0;i < limit;i++)
5034                         {
5035                                 if ((p = (r_cg_permutation_t*)Mem_ExpandableArray_RecordAtIndex(&r_cg_permutationarray, i)))
5036                                 {
5037                                         if (p->vprogram)
5038                                                 cgDestroyProgram(p->vprogram);
5039                                         if (p->fprogram)
5040                                                 cgDestroyProgram(p->fprogram);
5041                                         Mem_ExpandableArray_FreeRecord(&r_cg_permutationarray, (void*)p);
5042                                 }
5043                         }
5044                         memset(r_cg_permutationhash, 0, sizeof(r_cg_permutationhash));
5045                 }
5046 #endif
5047                 break;
5048         case RENDERPATH_GL13:
5049         case RENDERPATH_GL11:
5050                 break;
5051         }
5052 }
5053
5054 void R_GLSL_DumpShader_f(void)
5055 {
5056         int i;
5057         qfile_t *file;
5058
5059         file = FS_OpenRealFile("glsl/default.glsl", "w", false);
5060         if (file)
5061         {
5062                 FS_Print(file, "/* The engine may define the following macros:\n");
5063                 FS_Print(file, "#define VERTEX_SHADER\n#define GEOMETRY_SHADER\n#define FRAGMENT_SHADER\n");
5064                 for (i = 0;i < SHADERMODE_COUNT;i++)
5065                         FS_Print(file, glslshadermodeinfo[i].pretext);
5066                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
5067                         FS_Print(file, shaderpermutationinfo[i].pretext);
5068                 FS_Print(file, "*/\n");
5069                 FS_Print(file, builtinshaderstring);
5070                 FS_Close(file);
5071                 Con_Printf("glsl/default.glsl written\n");
5072         }
5073         else
5074                 Con_Printf("failed to write to glsl/default.glsl\n");
5075
5076 #ifdef SUPPORTCG
5077         file = FS_OpenRealFile("cg/default.cg", "w", false);
5078         if (file)
5079         {
5080                 FS_Print(file, "/* The engine may define the following macros:\n");
5081                 FS_Print(file, "#define VERTEX_SHADER\n#define GEOMETRY_SHADER\n#define FRAGMENT_SHADER\n");
5082                 for (i = 0;i < SHADERMODE_COUNT;i++)
5083                         FS_Print(file, cgshadermodeinfo[i].pretext);
5084                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
5085                         FS_Print(file, shaderpermutationinfo[i].pretext);
5086                 FS_Print(file, "*/\n");
5087                 FS_Print(file, builtincgshaderstring);
5088                 FS_Close(file);
5089                 Con_Printf("cg/default.cg written\n");
5090         }
5091         else
5092                 Con_Printf("failed to write to cg/default.cg\n");
5093 #endif
5094
5095 #ifdef SUPPORTD3D
5096         file = FS_OpenRealFile("hlsl/default.hlsl", "w", false);
5097         if (file)
5098         {
5099                 FS_Print(file, "/* The engine may define the following macros:\n");
5100                 FS_Print(file, "#define VERTEX_SHADER\n#define GEOMETRY_SHADER\n#define FRAGMENT_SHADER\n");
5101                 for (i = 0;i < SHADERMODE_COUNT;i++)
5102                         FS_Print(file, hlslshadermodeinfo[i].pretext);
5103                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
5104                         FS_Print(file, shaderpermutationinfo[i].pretext);
5105                 FS_Print(file, "*/\n");
5106                 FS_Print(file, builtincgshaderstring);
5107                 FS_Close(file);
5108                 Con_Printf("hlsl/default.hlsl written\n");
5109         }
5110         else
5111                 Con_Printf("failed to write to hlsl/default.hlsl\n");
5112 #endif
5113 }
5114
5115 void R_SetupShader_Generic(rtexture_t *first, rtexture_t *second, int texturemode, int rgbscale)
5116 {
5117         if (!second)
5118                 texturemode = GL_MODULATE;
5119         switch (vid.renderpath)
5120         {
5121         case RENDERPATH_D3D9:
5122 #ifdef SUPPORTD3D
5123                 R_SetupShader_SetPermutationHLSL(SHADERMODE_GENERIC, (first ? SHADERPERMUTATION_DIFFUSE : 0) | (second ? SHADERPERMUTATION_SPECULAR : 0) | (texturemode == GL_MODULATE ? SHADERPERMUTATION_COLORMAPPING : (texturemode == GL_ADD ? SHADERPERMUTATION_GLOW : (texturemode == GL_DECAL ? SHADERPERMUTATION_VERTEXTEXTUREBLEND : 0))));
5124                 R_Mesh_TexBind(GL20TU_FIRST , first );
5125                 R_Mesh_TexBind(GL20TU_SECOND, second);
5126 #endif
5127                 break;
5128         case RENDERPATH_D3D10:
5129                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5130                 break;
5131         case RENDERPATH_D3D11:
5132                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5133                 break;
5134         case RENDERPATH_GL20:
5135                 R_SetupShader_SetPermutationGLSL(SHADERMODE_GENERIC, (first ? SHADERPERMUTATION_DIFFUSE : 0) | (second ? SHADERPERMUTATION_SPECULAR : 0) | (texturemode == GL_MODULATE ? SHADERPERMUTATION_COLORMAPPING : (texturemode == GL_ADD ? SHADERPERMUTATION_GLOW : (texturemode == GL_DECAL ? SHADERPERMUTATION_VERTEXTEXTUREBLEND : 0))));
5136                 R_Mesh_TexBind(GL20TU_FIRST , first );
5137                 R_Mesh_TexBind(GL20TU_SECOND, second);
5138                 break;
5139         case RENDERPATH_CGGL:
5140 #ifdef SUPPORTCG
5141                 CHECKCGERROR
5142                 R_SetupShader_SetPermutationCG(SHADERMODE_GENERIC, (first ? SHADERPERMUTATION_DIFFUSE : 0) | (second ? SHADERPERMUTATION_SPECULAR : 0) | (texturemode == GL_MODULATE ? SHADERPERMUTATION_COLORMAPPING : (texturemode == GL_ADD ? SHADERPERMUTATION_GLOW : (texturemode == GL_DECAL ? SHADERPERMUTATION_VERTEXTEXTUREBLEND : 0))));
5143                 if (r_cg_permutation->fp_Texture_First ) CG_BindTexture(r_cg_permutation->fp_Texture_First , first );CHECKCGERROR
5144                 if (r_cg_permutation->fp_Texture_Second) CG_BindTexture(r_cg_permutation->fp_Texture_Second, second);CHECKCGERROR
5145 #endif
5146                 break;
5147         case RENDERPATH_GL13:
5148                 R_Mesh_TexBind(0, first );
5149                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
5150                 R_Mesh_TexBind(1, second);
5151                 if (second)
5152                         R_Mesh_TexCombine(1, texturemode, texturemode, rgbscale, 1);
5153                 break;
5154         case RENDERPATH_GL11:
5155                 R_Mesh_TexBind(0, first );
5156                 break;
5157         }
5158 }
5159
5160 void R_SetupShader_DepthOrShadow(void)
5161 {
5162         switch (vid.renderpath)
5163         {
5164         case RENDERPATH_D3D9:
5165 #ifdef SUPPORTD3D
5166                 R_SetupShader_SetPermutationHLSL(SHADERMODE_DEPTH_OR_SHADOW, 0);
5167 #endif
5168                 break;
5169         case RENDERPATH_D3D10:
5170                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5171                 break;
5172         case RENDERPATH_D3D11:
5173                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5174                 break;
5175         case RENDERPATH_GL20:
5176                 R_SetupShader_SetPermutationGLSL(SHADERMODE_DEPTH_OR_SHADOW, 0);
5177                 break;
5178         case RENDERPATH_CGGL:
5179 #ifdef SUPPORTCG
5180                 R_SetupShader_SetPermutationCG(SHADERMODE_DEPTH_OR_SHADOW, 0);
5181 #endif
5182                 break;
5183         case RENDERPATH_GL13:
5184                 R_Mesh_TexBind(0, 0);
5185                 R_Mesh_TexBind(1, 0);
5186                 break;
5187         case RENDERPATH_GL11:
5188                 R_Mesh_TexBind(0, 0);
5189                 break;
5190         }
5191 }
5192
5193 void R_SetupShader_ShowDepth(void)
5194 {
5195         switch (vid.renderpath)
5196         {
5197         case RENDERPATH_D3D9:
5198 #ifdef SUPPORTHLSL
5199                 R_SetupShader_SetPermutationHLSL(SHADERMODE_SHOWDEPTH, 0);
5200 #endif
5201                 break;
5202         case RENDERPATH_D3D10:
5203                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5204                 break;
5205         case RENDERPATH_D3D11:
5206                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5207                 break;
5208         case RENDERPATH_GL20:
5209                 R_SetupShader_SetPermutationGLSL(SHADERMODE_SHOWDEPTH, 0);
5210                 break;
5211         case RENDERPATH_CGGL:
5212 #ifdef SUPPORTCG
5213                 R_SetupShader_SetPermutationCG(SHADERMODE_SHOWDEPTH, 0);
5214 #endif
5215                 break;
5216         case RENDERPATH_GL13:
5217                 break;
5218         case RENDERPATH_GL11:
5219                 break;
5220         }
5221 }
5222
5223 extern qboolean r_shadow_usingdeferredprepass;
5224 extern cvar_t r_shadow_deferred_8bitrange;
5225 extern rtexture_t *r_shadow_attenuationgradienttexture;
5226 extern rtexture_t *r_shadow_attenuation2dtexture;
5227 extern rtexture_t *r_shadow_attenuation3dtexture;
5228 extern qboolean r_shadow_usingshadowmap2d;
5229 extern qboolean r_shadow_usingshadowmaportho;
5230 extern float r_shadow_shadowmap_texturescale[2];
5231 extern float r_shadow_shadowmap_parameters[4];
5232 extern qboolean r_shadow_shadowmapvsdct;
5233 extern qboolean r_shadow_shadowmapsampler;
5234 extern int r_shadow_shadowmappcf;
5235 extern rtexture_t *r_shadow_shadowmap2dtexture;
5236 extern rtexture_t *r_shadow_shadowmap2dcolortexture;
5237 extern rtexture_t *r_shadow_shadowmapvsdcttexture;
5238 extern matrix4x4_t r_shadow_shadowmapmatrix;
5239 extern int r_shadow_shadowmaplod; // changes for each light based on distance
5240 extern int r_shadow_prepass_width;
5241 extern int r_shadow_prepass_height;
5242 extern rtexture_t *r_shadow_prepassgeometrydepthtexture;
5243 extern rtexture_t *r_shadow_prepassgeometrynormalmaptexture;
5244 extern rtexture_t *r_shadow_prepassgeometrydepthcolortexture;
5245 extern rtexture_t *r_shadow_prepasslightingdiffusetexture;
5246 extern rtexture_t *r_shadow_prepasslightingspeculartexture;
5247 extern cvar_t gl_mesh_separatearrays;
5248 static qboolean R_BlendFuncAllowsColormod(int src, int dst)
5249 {
5250         // a blendfunc allows colormod if:
5251         // a) it can never keep the destination pixel invariant, or
5252         // b) it can keep the destination pixel invariant, and still can do so if colormodded
5253         // this is to prevent unintended side effects from colormod
5254
5255         // in formulas:
5256         // IF there is a (s, sa) for which for all (d, da),
5257         //   s * src(s, d, sa, da) + d * dst(s, d, sa, da) == d
5258         // THEN, for this (s, sa) and all (colormod, d, da):
5259         //   s*colormod * src(s*colormod, d, sa, da) + d * dst(s*colormod, d, sa, da) == d
5260         // OBVIOUSLY, this means that
5261         //   s*colormod * src(s*colormod, d, sa, da) = 0
5262         //   dst(s*colormod, d, sa, da)              = 1
5263
5264         // note: not caring about GL_SRC_ALPHA_SATURATE and following here, these are unused in DP code
5265
5266         // main condition to leave dst color invariant:
5267         //   s * src(s, d, sa, da) + d * dst(s, d, sa, da) == d
5268         //   src == GL_ZERO:
5269         //     s * 0 + d * dst(s, d, sa, da) == d
5270         //       => dst == GL_ONE/GL_SRC_COLOR/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
5271         //       => colormod is a problem for GL_SRC_COLOR only
5272         //   src == GL_ONE:
5273         //     s + d * dst(s, d, sa, da) == d
5274         //       => s == 0
5275         //       => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
5276         //       => colormod is never problematic for these
5277         //   src == GL_SRC_COLOR:
5278         //     s*s + d * dst(s, d, sa, da) == d
5279         //       => s == 0
5280         //       => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
5281         //       => colormod is never problematic for these
5282         //   src == GL_ONE_MINUS_SRC_COLOR:
5283         //     s*(1-s) + d * dst(s, d, sa, da) == d
5284         //       => s == 0 or s == 1
5285         //       => dst == GL_ONE/GL_SRC_COLOR/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
5286         //       => colormod is a problem for GL_SRC_COLOR only
5287         //   src == GL_DST_COLOR
5288         //     s*d + d * dst(s, d, sa, da) == d
5289         //       => s == 1
5290         //       => dst == GL_ZERO/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
5291         //       => colormod is always a problem
5292         //     or
5293         //       => s == 0
5294         //       => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
5295         //       => colormod is never problematic for these
5296         //       => BUT, we do not know s! We must assume it is problematic
5297         //       then... except in GL_ONE case, where we know all invariant
5298         //       cases are fine
5299         //   src == GL_ONE_MINUS_DST_COLOR
5300         //     s*(1-d) + d * dst(s, d, sa, da) == d
5301         //       => s == 0 (1-d is impossible to handle for our desired result)
5302         //       => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
5303         //       => colormod is never problematic for these
5304         //   src == GL_SRC_ALPHA
5305         //     s*sa + d * dst(s, d, sa, da) == d
5306         //       => s == 0, or sa == 0
5307         //       => dst == GL_ONE/GL_SRC_COLOR/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
5308         //       => colormod breaks in the case GL_SRC_COLOR only
5309         //   src == GL_ONE_MINUS_SRC_ALPHA
5310         //     s*(1-sa) + d * dst(s, d, sa, da) == d
5311         //       => s == 0, or sa == 1
5312         //       => dst == GL_ONE/GL_SRC_COLOR/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
5313         //       => colormod breaks in the case GL_SRC_COLOR only
5314         //   src == GL_DST_ALPHA
5315         //     s*da + d * dst(s, d, sa, da) == d
5316         //       => s == 0
5317         //       => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
5318         //       => colormod is never problematic for these
5319
5320         switch(src)
5321         {
5322                 case GL_ZERO:
5323                 case GL_ONE_MINUS_SRC_COLOR:
5324                 case GL_SRC_ALPHA:
5325                 case GL_ONE_MINUS_SRC_ALPHA:
5326                         if(dst == GL_SRC_COLOR)
5327                                 return false;
5328                         return true;
5329                 case GL_ONE:
5330                 case GL_SRC_COLOR:
5331                 case GL_ONE_MINUS_DST_COLOR:
5332                 case GL_DST_ALPHA:
5333                 case GL_ONE_MINUS_DST_ALPHA:
5334                         return true;
5335                 case GL_DST_COLOR:
5336                         if(dst == GL_ONE)
5337                                 return true;
5338                         return false;
5339                 default:
5340                         return false;
5341         }
5342 }
5343 void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, float ambientscale, float diffusescale, float specularscale, rsurfacepass_t rsurfacepass, int texturenumsurfaces, const msurface_t **texturesurfacelist, void *surfacewaterplane)
5344 {
5345         // select a permutation of the lighting shader appropriate to this
5346         // combination of texture, entity, light source, and fogging, only use the
5347         // minimum features necessary to avoid wasting rendering time in the
5348         // fragment shader on features that are not being used
5349         unsigned int permutation = 0;
5350         unsigned int mode = 0;
5351         qboolean allow_colormod;
5352         static float dummy_colormod[3] = {1, 1, 1};
5353         float *colormod = rsurface.colormod;
5354         float m16f[16];
5355         r_waterstate_waterplane_t *waterplane = (r_waterstate_waterplane_t *)surfacewaterplane;
5356         if (rsurfacepass == RSURFPASS_BACKGROUND)
5357         {
5358                 // distorted background
5359                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
5360                 {
5361                         mode = SHADERMODE_WATER;
5362                         if (rsurface.texture->r_water_waterscroll[0] && rsurface.texture->r_water_waterscroll[1])
5363                                 permutation |= SHADERPERMUTATION_NORMALMAPSCROLLBLEND;
5364                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5365                         allow_colormod = R_BlendFuncAllowsColormod(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5366                 }
5367                 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFRACTION)
5368                 {
5369                         mode = SHADERMODE_REFRACTION;
5370                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5371                         allow_colormod = R_BlendFuncAllowsColormod(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5372                 }
5373                 else
5374                 {
5375                         mode = SHADERMODE_GENERIC;
5376                         permutation |= SHADERPERMUTATION_DIFFUSE;
5377                         GL_BlendFunc(GL_ONE, GL_ZERO);
5378                         allow_colormod = R_BlendFuncAllowsColormod(GL_ONE, GL_ZERO);
5379                 }
5380                 GL_AlphaTest(false);
5381         }
5382         else if (rsurfacepass == RSURFPASS_DEFERREDGEOMETRY)
5383         {
5384                 if (r_glsl_offsetmapping.integer)
5385                 {
5386                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
5387                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5388                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
5389                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5390                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
5391                         {
5392                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5393                                 if (r_glsl_offsetmapping_reliefmapping.integer)
5394                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5395                         }
5396                 }
5397                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
5398                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
5399                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5400                         permutation |= SHADERPERMUTATION_ALPHAKILL;
5401                 // normalmap (deferred prepass), may use alpha test on diffuse
5402                 mode = SHADERMODE_DEFERREDGEOMETRY;
5403                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
5404                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
5405                 GL_AlphaTest(false);
5406                 GL_BlendFunc(GL_ONE, GL_ZERO);
5407                 allow_colormod = R_BlendFuncAllowsColormod(GL_ONE, GL_ZERO);
5408         }
5409         else if (rsurfacepass == RSURFPASS_RTLIGHT)
5410         {
5411                 if (r_glsl_offsetmapping.integer)
5412                 {
5413                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
5414                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5415                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
5416                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5417                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
5418                         {
5419                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5420                                 if (r_glsl_offsetmapping_reliefmapping.integer)
5421                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5422                         }
5423                 }
5424                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
5425                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
5426                 // light source
5427                 mode = SHADERMODE_LIGHTSOURCE;
5428                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
5429                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
5430                 if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
5431                         permutation |= SHADERPERMUTATION_CUBEFILTER;
5432                 if (diffusescale > 0)
5433                         permutation |= SHADERPERMUTATION_DIFFUSE;
5434                 if (specularscale > 0)
5435                         permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
5436                 if (r_refdef.fogenabled)
5437                         permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
5438                 if (rsurface.texture->colormapping)
5439                         permutation |= SHADERPERMUTATION_COLORMAPPING;
5440                 if (r_shadow_usingshadowmap2d)
5441                 {
5442                         permutation |= SHADERPERMUTATION_SHADOWMAP2D;
5443                         if(r_shadow_shadowmapvsdct)
5444                                 permutation |= SHADERPERMUTATION_SHADOWMAPVSDCT;
5445
5446                         if (r_shadow_shadowmapsampler)
5447                                 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
5448                         if (r_shadow_shadowmappcf > 1)
5449                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
5450                         else if (r_shadow_shadowmappcf)
5451                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
5452                 }
5453                 if (rsurface.texture->reflectmasktexture)
5454                         permutation |= SHADERPERMUTATION_REFLECTCUBE;
5455                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5456                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
5457                 allow_colormod = R_BlendFuncAllowsColormod(GL_SRC_ALPHA, GL_ONE);
5458         }
5459         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
5460         {
5461                 if (r_glsl_offsetmapping.integer)
5462                 {
5463                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
5464                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5465                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
5466                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5467                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
5468                         {
5469                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5470                                 if (r_glsl_offsetmapping_reliefmapping.integer)
5471                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5472                         }
5473                 }
5474                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
5475                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
5476                 // unshaded geometry (fullbright or ambient model lighting)
5477                 mode = SHADERMODE_FLATCOLOR;
5478                 ambientscale = diffusescale = specularscale = 0;
5479                 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
5480                         permutation |= SHADERPERMUTATION_GLOW;
5481                 if (r_refdef.fogenabled)
5482                         permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
5483                 if (rsurface.texture->colormapping)
5484                         permutation |= SHADERPERMUTATION_COLORMAPPING;
5485                 if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
5486                 {
5487                         permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
5488                         permutation |= SHADERPERMUTATION_SHADOWMAP2D;
5489
5490                         if (r_shadow_shadowmapsampler)
5491                                 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
5492                         if (r_shadow_shadowmappcf > 1)
5493                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
5494                         else if (r_shadow_shadowmappcf)
5495                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
5496                 }
5497                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
5498                         permutation |= SHADERPERMUTATION_REFLECTION;
5499                 if (rsurface.texture->reflectmasktexture)
5500                         permutation |= SHADERPERMUTATION_REFLECTCUBE;
5501                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5502                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5503                 allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5504         }
5505         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT_DIRECTIONAL)
5506         {
5507                 if (r_glsl_offsetmapping.integer)
5508                 {
5509                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
5510                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5511                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
5512                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5513                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
5514                         {
5515                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5516                                 if (r_glsl_offsetmapping_reliefmapping.integer)
5517                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5518                         }
5519                 }
5520                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
5521                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
5522                 // directional model lighting
5523                 mode = SHADERMODE_LIGHTDIRECTION;
5524                 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
5525                         permutation |= SHADERPERMUTATION_GLOW;
5526                 permutation |= SHADERPERMUTATION_DIFFUSE;
5527                 if (specularscale > 0)
5528                         permutation |= SHADERPERMUTATION_SPECULAR;
5529                 if (r_refdef.fogenabled)
5530                         permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
5531                 if (rsurface.texture->colormapping)
5532                         permutation |= SHADERPERMUTATION_COLORMAPPING;
5533                 if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
5534                 {
5535                         permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
5536                         permutation |= SHADERPERMUTATION_SHADOWMAP2D;
5537
5538                         if (r_shadow_shadowmapsampler)
5539                                 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
5540                         if (r_shadow_shadowmappcf > 1)
5541                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
5542                         else if (r_shadow_shadowmappcf)
5543                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
5544                 }
5545                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
5546                         permutation |= SHADERPERMUTATION_REFLECTION;
5547                 if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED))
5548                         permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
5549                 if (rsurface.texture->reflectmasktexture)
5550                         permutation |= SHADERPERMUTATION_REFLECTCUBE;
5551                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5552                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5553                 allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5554         }
5555         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
5556         {
5557                 if (r_glsl_offsetmapping.integer)
5558                 {
5559                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
5560                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5561                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
5562                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5563                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
5564                         {
5565                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5566                                 if (r_glsl_offsetmapping_reliefmapping.integer)
5567                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5568                         }
5569                 }
5570                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
5571                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
5572                 // ambient model lighting
5573                 mode = SHADERMODE_LIGHTDIRECTION;
5574                 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
5575                         permutation |= SHADERPERMUTATION_GLOW;
5576                 if (r_refdef.fogenabled)
5577                         permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
5578                 if (rsurface.texture->colormapping)
5579                         permutation |= SHADERPERMUTATION_COLORMAPPING;
5580                 if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
5581                 {
5582                         permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
5583                         permutation |= SHADERPERMUTATION_SHADOWMAP2D;
5584
5585                         if (r_shadow_shadowmapsampler)
5586                                 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
5587                         if (r_shadow_shadowmappcf > 1)
5588                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
5589                         else if (r_shadow_shadowmappcf)
5590                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
5591                 }
5592                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
5593                         permutation |= SHADERPERMUTATION_REFLECTION;
5594                 if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED))
5595                         permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
5596                 if (rsurface.texture->reflectmasktexture)
5597                         permutation |= SHADERPERMUTATION_REFLECTCUBE;
5598                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5599                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5600                 allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5601         }
5602         else
5603         {
5604                 if (r_glsl_offsetmapping.integer)
5605                 {
5606                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
5607                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5608                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
5609                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5610                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
5611                         {
5612                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5613                                 if (r_glsl_offsetmapping_reliefmapping.integer)
5614                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5615                         }
5616                 }
5617                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
5618                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
5619                 // lightmapped wall
5620                 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
5621                         permutation |= SHADERPERMUTATION_GLOW;
5622                 if (r_refdef.fogenabled)
5623                         permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
5624                 if (rsurface.texture->colormapping)
5625                         permutation |= SHADERPERMUTATION_COLORMAPPING;
5626                 if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
5627                 {
5628                         permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
5629                         permutation |= SHADERPERMUTATION_SHADOWMAP2D;
5630
5631                         if (r_shadow_shadowmapsampler)
5632                                 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
5633                         if (r_shadow_shadowmappcf > 1)
5634                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
5635                         else if (r_shadow_shadowmappcf)
5636                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
5637                 }
5638                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
5639                         permutation |= SHADERPERMUTATION_REFLECTION;
5640                 if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED))
5641                         permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
5642                 if (rsurface.texture->reflectmasktexture)
5643                         permutation |= SHADERPERMUTATION_REFLECTCUBE;
5644                 if (FAKELIGHT_ENABLED)
5645                 {
5646                         // fake lightmapping (q1bsp, q3bsp, fullbright map)
5647                         mode = SHADERMODE_FAKELIGHT;
5648                         permutation |= SHADERPERMUTATION_DIFFUSE;
5649                         if (specularscale > 0)
5650                                 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
5651                 }
5652                 else if (r_glsl_deluxemapping.integer >= 1 && rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping)
5653                 {
5654                         // deluxemapping (light direction texture)
5655                         if (rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping && r_refdef.scene.worldmodel->brushq3.deluxemapping_modelspace)
5656                                 mode = SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE;
5657                         else
5658                                 mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
5659                         permutation |= SHADERPERMUTATION_DIFFUSE;
5660                         if (specularscale > 0)
5661                                 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
5662                 }
5663                 else if (r_glsl_deluxemapping.integer >= 2 && rsurface.uselightmaptexture)
5664                 {
5665                         // fake deluxemapping (uniform light direction in tangentspace)
5666                         mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
5667                         permutation |= SHADERPERMUTATION_DIFFUSE;
5668                         if (specularscale > 0)
5669                                 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
5670                 }
5671                 else if (rsurface.uselightmaptexture)
5672                 {
5673                         // ordinary lightmapping (q1bsp, q3bsp)
5674                         mode = SHADERMODE_LIGHTMAP;
5675                 }
5676                 else
5677                 {
5678                         // ordinary vertex coloring (q3bsp)
5679                         mode = SHADERMODE_VERTEXCOLOR;
5680                 }
5681                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5682                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5683                 allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5684         }
5685         if(!allow_colormod)
5686                 colormod = dummy_colormod;
5687         switch(vid.renderpath)
5688         {
5689         case RENDERPATH_D3D9:
5690 #ifdef SUPPORTD3D
5691                 RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | (rsurface.modellightmapcolor4f ? BATCHNEED_VERTEXMESH_VERTEXCOLOR : 0) | BATCHNEED_VERTEXMESH_TEXCOORD | (rsurface.uselightmaptexture ? BATCHNEED_VERTEXMESH_LIGHTMAP : 0), texturenumsurfaces, texturesurfacelist);
5692                 R_Mesh_PrepareVertices_Mesh(rsurface.batchnumvertices, rsurface.batchvertexmesh, rsurface.batchvertexmeshbuffer);
5693                 R_SetupShader_SetPermutationHLSL(mode, permutation);
5694                 Matrix4x4_ToArrayFloatGL(&rsurface.matrix, m16f);hlslPSSetParameter16f(D3DPSREGISTER_ModelToReflectCube, m16f);
5695                 if (mode == SHADERMODE_LIGHTSOURCE)
5696                 {
5697                         Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);hlslVSSetParameter16f(D3DVSREGISTER_ModelToLight, m16f);
5698                         hlslVSSetParameter3f(D3DVSREGISTER_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
5699                 }
5700                 else
5701                 {
5702                         if (mode == SHADERMODE_LIGHTDIRECTION)
5703                         {
5704                                 hlslVSSetParameter3f(D3DVSREGISTER_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);
5705                         }
5706                 }
5707                 Matrix4x4_ToArrayFloatGL(&rsurface.texture->currenttexmatrix, m16f);hlslVSSetParameter16f(D3DVSREGISTER_TexMatrix, m16f);
5708                 Matrix4x4_ToArrayFloatGL(&rsurface.texture->currentbackgroundtexmatrix, m16f);hlslVSSetParameter16f(D3DVSREGISTER_BackgroundTexMatrix, m16f);
5709                 Matrix4x4_ToArrayFloatGL(&r_shadow_shadowmapmatrix, m16f);hlslVSSetParameter16f(D3DVSREGISTER_ShadowMapMatrix, m16f);
5710                 hlslVSSetParameter3f(D3DVSREGISTER_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);
5711                 hlslVSSetParameter4f(D3DVSREGISTER_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]);
5712
5713                 if (mode == SHADERMODE_LIGHTSOURCE)
5714                 {
5715                         hlslPSSetParameter3f(D3DPSREGISTER_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
5716                         hlslPSSetParameter3f(D3DPSREGISTER_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);
5717                         hlslPSSetParameter3f(D3DPSREGISTER_Color_Ambient, colormod[0] * ambientscale, colormod[1] * ambientscale, colormod[2] * ambientscale);
5718                         hlslPSSetParameter3f(D3DPSREGISTER_Color_Diffuse, colormod[0] * diffusescale, colormod[1] * diffusescale, colormod[2] * diffusescale);
5719                         hlslPSSetParameter3f(D3DPSREGISTER_Color_Specular, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale);
5720
5721                         // additive passes are only darkened by fog, not tinted
5722                         hlslPSSetParameter3f(D3DPSREGISTER_FogColor, 0, 0, 0);
5723                         hlslPSSetParameter1f(D3DPSREGISTER_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f));
5724                 }
5725                 else
5726                 {
5727                         if (mode == SHADERMODE_FLATCOLOR)
5728                         {
5729                                 hlslPSSetParameter3f(D3DPSREGISTER_Color_Ambient, colormod[0], colormod[1], colormod[2]);
5730                         }
5731                         else if (mode == SHADERMODE_LIGHTDIRECTION)
5732                         {
5733                                 hlslPSSetParameter3f(D3DPSREGISTER_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]);
5734                                 hlslPSSetParameter3f(D3DPSREGISTER_Color_Diffuse, r_refdef.lightmapintensity * colormod[0], r_refdef.lightmapintensity * colormod[1], r_refdef.lightmapintensity * colormod[2]);
5735                                 hlslPSSetParameter3f(D3DPSREGISTER_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);
5736                                 hlslPSSetParameter3f(D3DPSREGISTER_DeferredMod_Diffuse, colormod[0] * r_shadow_deferred_8bitrange.value, colormod[1] * r_shadow_deferred_8bitrange.value, colormod[2] * r_shadow_deferred_8bitrange.value);
5737                                 hlslPSSetParameter3f(D3DPSREGISTER_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value);
5738                                 hlslPSSetParameter3f(D3DPSREGISTER_LightColor, rsurface.modellight_diffuse[0], rsurface.modellight_diffuse[1], rsurface.modellight_diffuse[2]);
5739                                 hlslPSSetParameter3f(D3DPSREGISTER_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);
5740                         }
5741                         else
5742                         {
5743                                 hlslPSSetParameter3f(D3DPSREGISTER_Color_Ambient, r_refdef.scene.ambient * colormod[0], r_refdef.scene.ambient * colormod[1], r_refdef.scene.ambient * colormod[2]);
5744                                 hlslPSSetParameter3f(D3DPSREGISTER_Color_Diffuse, rsurface.texture->lightmapcolor[0], rsurface.texture->lightmapcolor[1], rsurface.texture->lightmapcolor[2]);
5745                                 hlslPSSetParameter3f(D3DPSREGISTER_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);
5746                                 hlslPSSetParameter3f(D3DPSREGISTER_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);
5747                                 hlslPSSetParameter3f(D3DPSREGISTER_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value);
5748                         }
5749                         // additive passes are only darkened by fog, not tinted
5750                         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
5751                                 hlslPSSetParameter3f(D3DPSREGISTER_FogColor, 0, 0, 0);
5752                         else
5753                                 hlslPSSetParameter3f(D3DPSREGISTER_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
5754                         hlslPSSetParameter4f(D3DPSREGISTER_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);
5755                         hlslPSSetParameter4f(D3DPSREGISTER_ScreenScaleRefractReflect, r_waterstate.screenscale[0], r_waterstate.screenscale[1], r_waterstate.screenscale[0], r_waterstate.screenscale[1]);
5756                         hlslPSSetParameter4f(D3DPSREGISTER_ScreenCenterRefractReflect, r_waterstate.screencenter[0], r_waterstate.screencenter[1], r_waterstate.screencenter[0], r_waterstate.screencenter[1]);
5757                         hlslPSSetParameter4f(D3DPSREGISTER_RefractColor, rsurface.texture->refractcolor4f[0], rsurface.texture->refractcolor4f[1], rsurface.texture->refractcolor4f[2], rsurface.texture->refractcolor4f[3] * rsurface.texture->lightmapcolor[3]);
5758                         hlslPSSetParameter4f(D3DPSREGISTER_ReflectColor, rsurface.texture->reflectcolor4f[0], rsurface.texture->reflectcolor4f[1], rsurface.texture->reflectcolor4f[2], rsurface.texture->reflectcolor4f[3] * rsurface.texture->lightmapcolor[3]);
5759                         hlslPSSetParameter1f(D3DPSREGISTER_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);
5760                         hlslPSSetParameter1f(D3DPSREGISTER_ReflectOffset, rsurface.texture->reflectmin);
5761                         hlslPSSetParameter1f(D3DPSREGISTER_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f));
5762                         if (mode == SHADERMODE_WATER)
5763                                 hlslPSSetParameter2f(D3DPSREGISTER_NormalmapScrollBlend, rsurface.texture->r_water_waterscroll[0], rsurface.texture->r_water_waterscroll[1]);
5764                 }
5765                 hlslPSSetParameter2f(D3DPSREGISTER_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);
5766                 hlslPSSetParameter4f(D3DPSREGISTER_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);
5767                 hlslPSSetParameter3f(D3DPSREGISTER_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]);
5768                 hlslPSSetParameter1f(D3DPSREGISTER_Alpha, rsurface.texture->lightmapcolor[3] * ((rsurface.texture->basematerialflags & MATERIALFLAG_WATERSHADER && r_waterstate.enabled && !r_refdef.view.isoverlay) ? rsurface.texture->r_water_wateralpha : 1));
5769                 hlslPSSetParameter3f(D3DPSREGISTER_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);
5770                 if (rsurface.texture->pantstexture)
5771                         hlslPSSetParameter3f(D3DPSREGISTER_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
5772                 else
5773                         hlslPSSetParameter3f(D3DPSREGISTER_Color_Pants, 0, 0, 0);
5774                 if (rsurface.texture->shirttexture)
5775                         hlslPSSetParameter3f(D3DPSREGISTER_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
5776                 else
5777                         hlslPSSetParameter3f(D3DPSREGISTER_Color_Shirt, 0, 0, 0);
5778                 hlslPSSetParameter4f(D3DPSREGISTER_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]);
5779                 hlslPSSetParameter1f(D3DPSREGISTER_FogPlaneViewDist, rsurface.fogplaneviewdist);
5780                 hlslPSSetParameter1f(D3DPSREGISTER_FogRangeRecip, rsurface.fograngerecip);
5781                 hlslPSSetParameter1f(D3DPSREGISTER_FogHeightFade, rsurface.fogheightfade);
5782                 hlslPSSetParameter1f(D3DPSREGISTER_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);
5783                 hlslPSSetParameter2f(D3DPSREGISTER_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);
5784                 hlslPSSetParameter2f(D3DPSREGISTER_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);
5785
5786                 R_Mesh_TexBind(GL20TU_NORMAL            , rsurface.texture->nmaptexture                       );
5787                 R_Mesh_TexBind(GL20TU_COLOR             , rsurface.texture->basetexture                       );
5788                 R_Mesh_TexBind(GL20TU_GLOSS             , rsurface.texture->glosstexture                      );
5789                 R_Mesh_TexBind(GL20TU_GLOW              , rsurface.texture->glowtexture                       );
5790                 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_NORMAL  , rsurface.texture->backgroundnmaptexture             );
5791                 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_COLOR   , rsurface.texture->backgroundbasetexture             );
5792                 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_GLOSS   , rsurface.texture->backgroundglosstexture            );
5793                 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_GLOW    , rsurface.texture->backgroundglowtexture             );
5794                 if (permutation & SHADERPERMUTATION_COLORMAPPING) R_Mesh_TexBind(GL20TU_PANTS             , rsurface.texture->pantstexture                      );
5795                 if (permutation & SHADERPERMUTATION_COLORMAPPING) R_Mesh_TexBind(GL20TU_SHIRT             , rsurface.texture->shirttexture                      );
5796                 if (permutation & SHADERPERMUTATION_REFLECTCUBE) R_Mesh_TexBind(GL20TU_REFLECTMASK       , rsurface.texture->reflectmasktexture                );
5797                 if (permutation & SHADERPERMUTATION_REFLECTCUBE) R_Mesh_TexBind(GL20TU_REFLECTCUBE       , rsurface.texture->reflectcubetexture ? rsurface.texture->reflectcubetexture : r_texture_whitecube);
5798                 if (permutation & SHADERPERMUTATION_FOGHEIGHTTEXTURE) R_Mesh_TexBind(GL20TU_FOGHEIGHTTEXTURE  , r_texture_fogheighttexture                          );
5799                 if (permutation & (SHADERPERMUTATION_FOGINSIDE | SHADERPERMUTATION_FOGOUTSIDE)) R_Mesh_TexBind(GL20TU_FOGMASK           , r_texture_fogattenuation                            );
5800                 R_Mesh_TexBind(GL20TU_LIGHTMAP          , rsurface.lightmaptexture ? rsurface.lightmaptexture : r_texture_white);
5801                 R_Mesh_TexBind(GL20TU_DELUXEMAP         , rsurface.deluxemaptexture ? rsurface.deluxemaptexture : r_texture_blanknormalmap);
5802                 if (rsurface.rtlight                                  ) R_Mesh_TexBind(GL20TU_ATTENUATION       , r_shadow_attenuationgradienttexture                 );
5803                 if (rsurfacepass == RSURFPASS_BACKGROUND)
5804                 {
5805                         R_Mesh_TexBind(GL20TU_REFRACTION        , waterplane->texture_refraction ? waterplane->texture_refraction : r_texture_black);
5806                         if(mode == SHADERMODE_GENERIC) R_Mesh_TexBind(GL20TU_FIRST             , waterplane->texture_camera ? waterplane->texture_camera : r_texture_black);
5807                         R_Mesh_TexBind(GL20TU_REFLECTION        , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);
5808                 }
5809                 else
5810                 {
5811                         if (permutation & SHADERPERMUTATION_REFLECTION        ) R_Mesh_TexBind(GL20TU_REFLECTION        , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);
5812                 }
5813 //              if (rsurfacepass == RSURFPASS_DEFERREDLIGHT           ) R_Mesh_TexBind(GL20TU_SCREENDEPTH       , r_shadow_prepassgeometrydepthtexture                );
5814 //              if (rsurfacepass == RSURFPASS_DEFERREDLIGHT           ) R_Mesh_TexBind(GL20TU_SCREENNORMALMAP   , r_shadow_prepassgeometrynormalmaptexture            );
5815                 if (permutation & SHADERPERMUTATION_DEFERREDLIGHTMAP  ) R_Mesh_TexBind(GL20TU_SCREENDIFFUSE     , r_shadow_prepasslightingdiffusetexture              );
5816                 if (permutation & SHADERPERMUTATION_DEFERREDLIGHTMAP  ) R_Mesh_TexBind(GL20TU_SCREENSPECULAR    , r_shadow_prepasslightingspeculartexture             );
5817                 if (rsurface.rtlight || (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW)))
5818                 {
5819                         R_Mesh_TexBind(GL20TU_SHADOWMAP2D, r_shadow_shadowmap2dcolortexture);
5820                         if (rsurface.rtlight)
5821                         {
5822                                 if (permutation & SHADERPERMUTATION_CUBEFILTER        ) R_Mesh_TexBind(GL20TU_CUBE              , rsurface.rtlight->currentcubemap                    );
5823                                 if (permutation & SHADERPERMUTATION_SHADOWMAPVSDCT    ) R_Mesh_TexBind(GL20TU_CUBEPROJECTION    , r_shadow_shadowmapvsdcttexture                      );
5824                         }
5825                 }
5826 #endif
5827                 break;
5828         case RENDERPATH_D3D10:
5829                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5830                 break;
5831         case RENDERPATH_D3D11:
5832                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5833                 break;
5834         case RENDERPATH_GL20:
5835                 if (gl_mesh_separatearrays.integer)
5836                 {
5837                         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | (rsurface.modellightmapcolor4f ? BATCHNEED_ARRAY_VERTEXCOLOR : 0) | BATCHNEED_ARRAY_TEXCOORD | (rsurface.uselightmaptexture ? BATCHNEED_ARRAY_LIGHTMAP : 0), texturenumsurfaces, texturesurfacelist);
5838                         R_Mesh_VertexPointer(     3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
5839                         R_Mesh_ColorPointer(      4, GL_FLOAT, sizeof(float[4]), rsurface.batchlightmapcolor4f, rsurface.batchlightmapcolor4f_vertexbuffer, rsurface.batchlightmapcolor4f_bufferoffset);
5840                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
5841                         R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchsvector3f, rsurface.batchsvector3f_vertexbuffer, rsurface.batchsvector3f_bufferoffset);
5842                         R_Mesh_TexCoordPointer(2, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchtvector3f, rsurface.batchtvector3f_vertexbuffer, rsurface.batchtvector3f_bufferoffset);
5843                         R_Mesh_TexCoordPointer(3, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchnormal3f, rsurface.batchnormal3f_vertexbuffer, rsurface.batchnormal3f_bufferoffset);
5844                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordlightmap2f_vertexbuffer, rsurface.batchtexcoordlightmap2f_bufferoffset);
5845                 }
5846                 else
5847                 {
5848                         RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | (rsurface.modellightmapcolor4f ? BATCHNEED_VERTEXMESH_VERTEXCOLOR : 0) | BATCHNEED_VERTEXMESH_TEXCOORD | (rsurface.uselightmaptexture ? BATCHNEED_VERTEXMESH_LIGHTMAP : 0), texturenumsurfaces, texturesurfacelist);
5849                         R_Mesh_PrepareVertices_Mesh(rsurface.batchnumvertices, rsurface.batchvertexmesh, rsurface.batchvertexmeshbuffer);
5850                 }
5851                 R_SetupShader_SetPermutationGLSL(mode, permutation);
5852                 if (r_glsl_permutation->loc_ModelToReflectCube >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.matrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelToReflectCube, 1, false, m16f);}
5853                 if (mode == SHADERMODE_LIGHTSOURCE)
5854                 {
5855                         if (r_glsl_permutation->loc_ModelToLight >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelToLight, 1, false, m16f);}
5856                         if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
5857                         if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);
5858                         if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, colormod[0] * ambientscale, colormod[1] * ambientscale, colormod[2] * ambientscale);
5859                         if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Diffuse, colormod[0] * diffusescale, colormod[1] * diffusescale, colormod[2] * diffusescale);
5860                         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);
5861
5862                         // additive passes are only darkened by fog, not tinted
5863                         if (r_glsl_permutation->loc_FogColor >= 0)
5864                                 qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
5865                         if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f));
5866                 }
5867                 else
5868                 {
5869                         if (mode == SHADERMODE_FLATCOLOR)
5870                         {
5871                                 if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, colormod[0], colormod[1], colormod[2]);
5872                         }
5873                         else if (mode == SHADERMODE_LIGHTDIRECTION)
5874                         {
5875                                 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]);
5876                                 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]);
5877                                 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);
5878                                 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);
5879                                 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);
5880                                 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]);
5881                                 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]);
5882                         }
5883                         else
5884                         {
5885                                 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]);
5886                                 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]);
5887                                 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);
5888                                 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);
5889                                 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);
5890                         }
5891                         // additive passes are only darkened by fog, not tinted
5892                         if (r_glsl_permutation->loc_FogColor >= 0)
5893                         {
5894                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
5895                                         qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
5896                                 else
5897                                         qglUniform3fARB(r_glsl_permutation->loc_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
5898                         }
5899                         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);
5900                         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]);
5901                         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]);
5902                         if (r_glsl_permutation->loc_RefractColor >= 0) qglUniform4fARB(r_glsl_permutation->loc_RefractColor, rsurface.texture->refractcolor4f[0], rsurface.texture->refractcolor4f[1], rsurface.texture->refractcolor4f[2], rsurface.texture->refractcolor4f[3] * rsurface.texture->lightmapcolor[3]);
5903                         if (r_glsl_permutation->loc_ReflectColor >= 0) qglUniform4fARB(r_glsl_permutation->loc_ReflectColor, rsurface.texture->reflectcolor4f[0], rsurface.texture->reflectcolor4f[1], rsurface.texture->reflectcolor4f[2], rsurface.texture->reflectcolor4f[3] * rsurface.texture->lightmapcolor[3]);
5904                         if (r_glsl_permutation->loc_ReflectFactor >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);
5905                         if (r_glsl_permutation->loc_ReflectOffset >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectOffset, rsurface.texture->reflectmin);
5906                         if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f));
5907                         if (r_glsl_permutation->loc_NormalmapScrollBlend >= 0) qglUniform2fARB(r_glsl_permutation->loc_NormalmapScrollBlend, rsurface.texture->r_water_waterscroll[0], rsurface.texture->r_water_waterscroll[1]);
5908                 }
5909                 if (r_glsl_permutation->loc_TexMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currenttexmatrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_TexMatrix, 1, false, m16f);}
5910                 if (r_glsl_permutation->loc_BackgroundTexMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currentbackgroundtexmatrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_BackgroundTexMatrix, 1, false, m16f);}
5911                 if (r_glsl_permutation->loc_ShadowMapMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&r_shadow_shadowmapmatrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_ShadowMapMatrix, 1, false, m16f);}
5912                 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]);
5913                 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]);
5914
5915                 if (r_glsl_permutation->loc_Color_Glow >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]);
5916                 if (r_glsl_permutation->loc_Alpha >= 0) qglUniform1fARB(r_glsl_permutation->loc_Alpha, rsurface.texture->lightmapcolor[3] * ((rsurface.texture->basematerialflags & MATERIALFLAG_WATERSHADER && r_waterstate.enabled && !r_refdef.view.isoverlay) ? rsurface.texture->r_water_wateralpha : 1));
5917                 if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);
5918                 if (r_glsl_permutation->loc_Color_Pants >= 0)
5919                 {
5920                         if (rsurface.texture->pantstexture)
5921                                 qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
5922                         else
5923                                 qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, 0, 0, 0);
5924                 }
5925                 if (r_glsl_permutation->loc_Color_Shirt >= 0)
5926                 {
5927                         if (rsurface.texture->shirttexture)
5928                                 qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
5929                         else
5930                                 qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, 0, 0, 0);
5931                 }
5932                 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]);
5933                 if (r_glsl_permutation->loc_FogPlaneViewDist >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogPlaneViewDist, rsurface.fogplaneviewdist);
5934                 if (r_glsl_permutation->loc_FogRangeRecip >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogRangeRecip, rsurface.fograngerecip);
5935                 if (r_glsl_permutation->loc_FogHeightFade >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogHeightFade, rsurface.fogheightfade);
5936                 if (r_glsl_permutation->loc_OffsetMapping_Scale >= 0) qglUniform1fARB(r_glsl_permutation->loc_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value*rsurface.texture->offsetscale);
5937                 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]);
5938                 if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
5939
5940         //      if (r_glsl_permutation->loc_Texture_First           >= 0) R_Mesh_TexBind(GL20TU_FIRST             , r_texture_white                                     );
5941         //      if (r_glsl_permutation->loc_Texture_Second          >= 0) R_Mesh_TexBind(GL20TU_SECOND            , r_texture_white                                     );
5942         //      if (r_glsl_permutation->loc_Texture_GammaRamps      >= 0) R_Mesh_TexBind(GL20TU_GAMMARAMPS        , r_texture_gammaramps                                );
5943                 if (r_glsl_permutation->loc_Texture_Normal          >= 0) R_Mesh_TexBind(GL20TU_NORMAL            , rsurface.texture->nmaptexture                       );
5944                 if (r_glsl_permutation->loc_Texture_Color           >= 0) R_Mesh_TexBind(GL20TU_COLOR             , rsurface.texture->basetexture                       );
5945                 if (r_glsl_permutation->loc_Texture_Gloss           >= 0) R_Mesh_TexBind(GL20TU_GLOSS             , rsurface.texture->glosstexture                      );
5946                 if (r_glsl_permutation->loc_Texture_Glow            >= 0) R_Mesh_TexBind(GL20TU_GLOW              , rsurface.texture->glowtexture                       );
5947                 if (r_glsl_permutation->loc_Texture_SecondaryNormal >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_NORMAL  , rsurface.texture->backgroundnmaptexture             );
5948                 if (r_glsl_permutation->loc_Texture_SecondaryColor  >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_COLOR   , rsurface.texture->backgroundbasetexture             );
5949                 if (r_glsl_permutation->loc_Texture_SecondaryGloss  >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_GLOSS   , rsurface.texture->backgroundglosstexture            );
5950                 if (r_glsl_permutation->loc_Texture_SecondaryGlow   >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_GLOW    , rsurface.texture->backgroundglowtexture             );
5951                 if (r_glsl_permutation->loc_Texture_Pants           >= 0) R_Mesh_TexBind(GL20TU_PANTS             , rsurface.texture->pantstexture                      );
5952                 if (r_glsl_permutation->loc_Texture_Shirt           >= 0) R_Mesh_TexBind(GL20TU_SHIRT             , rsurface.texture->shirttexture                      );
5953                 if (r_glsl_permutation->loc_Texture_ReflectMask     >= 0) R_Mesh_TexBind(GL20TU_REFLECTMASK       , rsurface.texture->reflectmasktexture                );
5954                 if (r_glsl_permutation->loc_Texture_ReflectCube     >= 0) R_Mesh_TexBind(GL20TU_REFLECTCUBE       , rsurface.texture->reflectcubetexture ? rsurface.texture->reflectcubetexture : r_texture_whitecube);
5955                 if (r_glsl_permutation->loc_Texture_FogHeightTexture>= 0) R_Mesh_TexBind(GL20TU_FOGHEIGHTTEXTURE  , r_texture_fogheighttexture                          );
5956                 if (r_glsl_permutation->loc_Texture_FogMask         >= 0) R_Mesh_TexBind(GL20TU_FOGMASK           , r_texture_fogattenuation                            );
5957                 if (r_glsl_permutation->loc_Texture_Lightmap        >= 0) R_Mesh_TexBind(GL20TU_LIGHTMAP          , rsurface.lightmaptexture ? rsurface.lightmaptexture : r_texture_white);
5958                 if (r_glsl_permutation->loc_Texture_Deluxemap       >= 0) R_Mesh_TexBind(GL20TU_DELUXEMAP         , rsurface.deluxemaptexture ? rsurface.deluxemaptexture : r_texture_blanknormalmap);
5959                 if (r_glsl_permutation->loc_Texture_Attenuation     >= 0) R_Mesh_TexBind(GL20TU_ATTENUATION       , r_shadow_attenuationgradienttexture                 );
5960                 if (rsurfacepass == RSURFPASS_BACKGROUND)
5961                 {
5962                         if(r_glsl_permutation->loc_Texture_Refraction >= 0) R_Mesh_TexBind(GL20TU_REFRACTION        , waterplane->texture_refraction ? waterplane->texture_refraction : r_texture_black);
5963                         else if(r_glsl_permutation->loc_Texture_First >= 0) R_Mesh_TexBind(GL20TU_FIRST             , waterplane->texture_camera ? waterplane->texture_camera : r_texture_black);
5964                         if(r_glsl_permutation->loc_Texture_Reflection >= 0) R_Mesh_TexBind(GL20TU_REFLECTION        , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);
5965                 }
5966                 else
5967                 {
5968                         if (permutation & SHADERPERMUTATION_REFLECTION        ) R_Mesh_TexBind(GL20TU_REFLECTION        , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);
5969                 }
5970 //              if (r_glsl_permutation->loc_Texture_ScreenDepth     >= 0) R_Mesh_TexBind(GL20TU_SCREENDEPTH       , r_shadow_prepassgeometrydepthtexture                );
5971 //              if (r_glsl_permutation->loc_Texture_ScreenNormalMap >= 0) R_Mesh_TexBind(GL20TU_SCREENNORMALMAP   , r_shadow_prepassgeometrynormalmaptexture            );
5972                 if (r_glsl_permutation->loc_Texture_ScreenDiffuse   >= 0) R_Mesh_TexBind(GL20TU_SCREENDIFFUSE     , r_shadow_prepasslightingdiffusetexture              );
5973                 if (r_glsl_permutation->loc_Texture_ScreenSpecular  >= 0) R_Mesh_TexBind(GL20TU_SCREENSPECULAR    , r_shadow_prepasslightingspeculartexture             );
5974                 if (rsurface.rtlight || (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW)))
5975                 {
5976                         if (r_glsl_permutation->loc_Texture_ShadowMap2D     >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAP2D, r_shadow_shadowmap2dtexture                         );
5977                         if (rsurface.rtlight)
5978                         {
5979                                 if (r_glsl_permutation->loc_Texture_Cube            >= 0) R_Mesh_TexBind(GL20TU_CUBE              , rsurface.rtlight->currentcubemap                    );
5980                                 if (r_glsl_permutation->loc_Texture_CubeProjection  >= 0) R_Mesh_TexBind(GL20TU_CUBEPROJECTION    , r_shadow_shadowmapvsdcttexture                      );
5981                         }
5982                 }
5983                 CHECKGLERROR
5984                 break;
5985         case RENDERPATH_CGGL:
5986 #ifdef SUPPORTCG
5987                 if (gl_mesh_separatearrays.integer)
5988                 {
5989                         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | (rsurface.modellightmapcolor4f ? BATCHNEED_ARRAY_VERTEXCOLOR : 0) | BATCHNEED_ARRAY_TEXCOORD | (rsurface.uselightmaptexture ? BATCHNEED_ARRAY_LIGHTMAP : 0), texturenumsurfaces, texturesurfacelist);
5990                         R_Mesh_VertexPointer(     3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
5991                         R_Mesh_ColorPointer(      4, GL_FLOAT, sizeof(float[4]), rsurface.batchlightmapcolor4f, rsurface.batchlightmapcolor4f_vertexbuffer, rsurface.batchlightmapcolor4f_bufferoffset);
5992                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
5993                         R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchsvector3f, rsurface.batchsvector3f_vertexbuffer, rsurface.batchsvector3f_bufferoffset);
5994                         R_Mesh_TexCoordPointer(2, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchtvector3f, rsurface.batchtvector3f_vertexbuffer, rsurface.batchtvector3f_bufferoffset);
5995                         R_Mesh_TexCoordPointer(3, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchnormal3f, rsurface.batchnormal3f_vertexbuffer, rsurface.batchnormal3f_bufferoffset);
5996                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordlightmap2f_vertexbuffer, rsurface.batchtexcoordlightmap2f_bufferoffset);
5997                 }
5998                 else
5999                 {
6000                         RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | (rsurface.modellightmapcolor4f ? BATCHNEED_VERTEXMESH_VERTEXCOLOR : 0) | BATCHNEED_VERTEXMESH_TEXCOORD | (rsurface.uselightmaptexture ? BATCHNEED_VERTEXMESH_LIGHTMAP : 0), texturenumsurfaces, texturesurfacelist);
6001                         R_Mesh_PrepareVertices_Mesh(rsurface.batchnumvertices, rsurface.batchvertexmesh, rsurface.batchvertexmeshbuffer);
6002                 }
6003                 R_SetupShader_SetPermutationCG(mode, permutation);
6004                 if (r_cg_permutation->fp_ModelToReflectCube) {Matrix4x4_ToArrayFloatGL(&rsurface.matrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->fp_ModelToReflectCube, m16f);}CHECKCGERROR
6005                 if (mode == SHADERMODE_LIGHTSOURCE)
6006                 {
6007                         if (r_cg_permutation->vp_ModelToLight) {Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelToLight, m16f);}CHECKCGERROR
6008                         if (r_cg_permutation->vp_LightPosition) cgGLSetParameter3f(r_cg_permutation->vp_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);CHECKCGERROR
6009                 }
6010                 else
6011                 {
6012                         if (mode == SHADERMODE_LIGHTDIRECTION)
6013                         {
6014                                 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
6015                         }
6016                 }
6017                 if (r_cg_permutation->vp_TexMatrix) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currenttexmatrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_TexMatrix, m16f);}CHECKCGERROR
6018                 if (r_cg_permutation->vp_BackgroundTexMatrix) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currentbackgroundtexmatrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_BackgroundTexMatrix, m16f);}CHECKCGERROR
6019                 if (r_cg_permutation->vp_ShadowMapMatrix) {Matrix4x4_ToArrayFloatGL(&r_shadow_shadowmapmatrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_ShadowMapMatrix, m16f);}CHECKGLERROR
6020                 if (r_cg_permutation->vp_EyePosition) cgGLSetParameter3f(r_cg_permutation->vp_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);CHECKCGERROR
6021                 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
6022                 CHECKGLERROR
6023
6024                 if (mode == SHADERMODE_LIGHTSOURCE)
6025                 {
6026                         if (r_cg_permutation->fp_LightPosition) cgGLSetParameter3f(r_cg_permutation->fp_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);CHECKCGERROR
6027                         if (r_cg_permutation->fp_LightColor) cgGLSetParameter3f(r_cg_permutation->fp_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);CHECKCGERROR
6028                         if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, colormod[0] * ambientscale, colormod[1] * ambientscale, colormod[2] * ambientscale);CHECKCGERROR
6029                         if (r_cg_permutation->fp_Color_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_Color_Diffuse, colormod[0] * diffusescale, colormod[1] * diffusescale, colormod[2] * diffusescale);CHECKCGERROR
6030                         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
6031
6032                         // additive passes are only darkened by fog, not tinted
6033                         if (r_cg_permutation->fp_FogColor) cgGLSetParameter3f(r_cg_permutation->fp_FogColor, 0, 0, 0);CHECKCGERROR
6034                         if (r_cg_permutation->fp_SpecularPower) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f));CHECKCGERROR
6035                 }
6036                 else
6037                 {
6038                         if (mode == SHADERMODE_FLATCOLOR)
6039                         {
6040                                 if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, colormod[0], colormod[1], colormod[2]);CHECKCGERROR
6041                         }
6042                         else if (mode == SHADERMODE_LIGHTDIRECTION)
6043                         {
6044                                 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
6045                                 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
6046                                 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
6047                                 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
6048                                 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
6049                                 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
6050                                 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
6051                         }
6052                         else
6053                         {
6054                                 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
6055                                 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
6056                                 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
6057                                 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
6058                                 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
6059                         }
6060                         // additive passes are only darkened by fog, not tinted
6061                         if (r_cg_permutation->fp_FogColor)
6062                         {
6063                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
6064                                         cgGLSetParameter3f(r_cg_permutation->fp_FogColor, 0, 0, 0);
6065                                 else
6066                                         cgGLSetParameter3f(r_cg_permutation->fp_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
6067                                 CHECKCGERROR
6068                         }
6069                         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
6070                         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
6071                         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
6072                         if (r_cg_permutation->fp_RefractColor) cgGLSetParameter4fv(r_cg_permutation->fp_RefractColor, rsurface.texture->refractcolor4f[0], rsurface.texture->refractcolor4f[1], rsurface.texture->refractcolor4f[2], rsurface.texture->refractcolor4f[3] * rsurface.texture->lightmapcolor[3]);CHECKCGERROR
6073                         if (r_cg_permutation->fp_ReflectColor) cgGLSetParameter4fv(r_cg_permutation->fp_ReflectColor, rsurface.texture->reflectcolor4f[0], rsurface.texture->reflectcolor4f[1], rsurface.texture->reflectcolor4f[2], rsurface.texture->reflectcolor4f[3] * rsurface.texture->lightmapcolor[3]);CHECKCGERROR
6074                         if (r_cg_permutation->fp_ReflectFactor) cgGLSetParameter1f(r_cg_permutation->fp_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);CHECKCGERROR
6075                         if (r_cg_permutation->fp_ReflectOffset) cgGLSetParameter1f(r_cg_permutation->fp_ReflectOffset, rsurface.texture->reflectmin);CHECKCGERROR
6076                         if (r_cg_permutation->fp_SpecularPower) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f));CHECKCGERROR
6077                         if (r_cg_permutation->fp_NormalmapScrollBlend) cgGLSetParameter2f(r_cg_permutation->fp_NormalmapScrollBlend, rsurface.texture->r_water_waterscroll[0], rsurface.texture->r_water_waterscroll[1]);
6078                 }
6079                 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
6080                 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
6081                 if (r_cg_permutation->fp_Color_Glow) cgGLSetParameter3f(r_cg_permutation->fp_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]);CHECKCGERROR
6082                 if (r_cg_permutation->fp_Alpha) cgGLSetParameter1f(r_cg_permutation->fp_Alpha, rsurface.texture->lightmapcolor[3] * ((rsurface.texture->basematerialflags & MATERIALFLAG_WATERSHADER && r_waterstate.enabled && !r_refdef.view.isoverlay) ? rsurface.texture->r_water_wateralpha : 1));CHECKCGERROR
6083                 if (r_cg_permutation->fp_EyePosition) cgGLSetParameter3f(r_cg_permutation->fp_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);CHECKCGERROR
6084                 if (r_cg_permutation->fp_Color_Pants)
6085                 {
6086                         if (rsurface.texture->pantstexture)
6087                                 cgGLSetParameter3f(r_cg_permutation->fp_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
6088                         else
6089                                 cgGLSetParameter3f(r_cg_permutation->fp_Color_Pants, 0, 0, 0);
6090                         CHECKCGERROR
6091                 }
6092                 if (r_cg_permutation->fp_Color_Shirt)
6093                 {
6094                         if (rsurface.texture->shirttexture)
6095                                 cgGLSetParameter3f(r_cg_permutation->fp_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
6096                         else
6097                                 cgGLSetParameter3f(r_cg_permutation->fp_Color_Shirt, 0, 0, 0);
6098                         CHECKCGERROR
6099                 }
6100                 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
6101                 if (r_cg_permutation->fp_FogPlaneViewDist) cgGLSetParameter1f(r_cg_permutation->fp_FogPlaneViewDist, rsurface.fogplaneviewdist);CHECKCGERROR
6102                 if (r_cg_permutation->fp_FogRangeRecip) cgGLSetParameter1f(r_cg_permutation->fp_FogRangeRecip, rsurface.fograngerecip);CHECKCGERROR
6103                 if (r_cg_permutation->fp_FogHeightFade) cgGLSetParameter1f(r_cg_permutation->fp_FogHeightFade, rsurface.fogheightfade);CHECKCGERROR
6104                 if (r_cg_permutation->fp_OffsetMapping_Scale) cgGLSetParameter1f(r_cg_permutation->fp_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);CHECKCGERROR
6105                 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
6106                 if (r_cg_permutation->fp_PixelToScreenTexCoord) cgGLSetParameter2f(r_cg_permutation->fp_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);CHECKCGERROR
6107
6108         //      if (r_cg_permutation->fp_Texture_First          ) CG_BindTexture(r_cg_permutation->fp_Texture_First          , r_texture_white                                     );CHECKCGERROR
6109         //      if (r_cg_permutation->fp_Texture_Second         ) CG_BindTexture(r_cg_permutation->fp_Texture_Second         , r_texture_white                                     );CHECKCGERROR
6110         //      if (r_cg_permutation->fp_Texture_GammaRamps     ) CG_BindTexture(r_cg_permutation->fp_Texture_GammaRamps     , r_texture_gammaramps                                );CHECKCGERROR
6111                 if (r_cg_permutation->fp_Texture_Normal         ) CG_BindTexture(r_cg_permutation->fp_Texture_Normal         , rsurface.texture->nmaptexture                       );CHECKCGERROR
6112                 if (r_cg_permutation->fp_Texture_Color          ) CG_BindTexture(r_cg_permutation->fp_Texture_Color          , rsurface.texture->basetexture                       );CHECKCGERROR
6113                 if (r_cg_permutation->fp_Texture_Gloss          ) CG_BindTexture(r_cg_permutation->fp_Texture_Gloss          , rsurface.texture->glosstexture                      );CHECKCGERROR
6114                 if (r_cg_permutation->fp_Texture_Glow           ) CG_BindTexture(r_cg_permutation->fp_Texture_Glow           , rsurface.texture->glowtexture                       );CHECKCGERROR
6115                 if (r_cg_permutation->fp_Texture_SecondaryNormal) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryNormal, rsurface.texture->backgroundnmaptexture             );CHECKCGERROR
6116                 if (r_cg_permutation->fp_Texture_SecondaryColor ) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryColor , rsurface.texture->backgroundbasetexture             );CHECKCGERROR
6117                 if (r_cg_permutation->fp_Texture_SecondaryGloss ) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryGloss , rsurface.texture->backgroundglosstexture            );CHECKCGERROR
6118                 if (r_cg_permutation->fp_Texture_SecondaryGlow  ) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryGlow  , rsurface.texture->backgroundglowtexture             );CHECKCGERROR
6119                 if (r_cg_permutation->fp_Texture_Pants          ) CG_BindTexture(r_cg_permutation->fp_Texture_Pants          , rsurface.texture->pantstexture                      );CHECKCGERROR
6120                 if (r_cg_permutation->fp_Texture_Shirt          ) CG_BindTexture(r_cg_permutation->fp_Texture_Shirt          , rsurface.texture->shirttexture                      );CHECKCGERROR
6121                 if (r_cg_permutation->fp_Texture_ReflectMask    ) CG_BindTexture(r_cg_permutation->fp_Texture_ReflectMask    , rsurface.texture->reflectmasktexture                );CHECKCGERROR
6122                 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
6123                 if (r_cg_permutation->fp_Texture_FogHeightTexture) CG_BindTexture(r_cg_permutation->fp_Texture_FogHeightTexture, r_texture_fogheighttexture                         );CHECKCGERROR
6124                 if (r_cg_permutation->fp_Texture_FogMask        ) CG_BindTexture(r_cg_permutation->fp_Texture_FogMask        , r_texture_fogattenuation                            );CHECKCGERROR
6125                 if (r_cg_permutation->fp_Texture_Lightmap       ) CG_BindTexture(r_cg_permutation->fp_Texture_Lightmap       , rsurface.lightmaptexture ? rsurface.lightmaptexture : r_texture_white);CHECKCGERROR
6126                 if (r_cg_permutation->fp_Texture_Deluxemap      ) CG_BindTexture(r_cg_permutation->fp_Texture_Deluxemap      , rsurface.deluxemaptexture ? rsurface.deluxemaptexture : r_texture_blanknormalmap);CHECKCGERROR
6127                 if (r_cg_permutation->fp_Texture_Attenuation    ) CG_BindTexture(r_cg_permutation->fp_Texture_Attenuation    , r_shadow_attenuationgradienttexture                 );CHECKCGERROR
6128                 if (rsurfacepass == RSURFPASS_BACKGROUND)
6129                 {
6130                         if (r_cg_permutation->fp_Texture_Refraction     ) CG_BindTexture(r_cg_permutation->fp_Texture_Refraction     , waterplane->texture_refraction ? waterplane->texture_refraction : r_texture_black);CHECKCGERROR
6131                         else if (r_cg_permutation->fp_Texture_First     ) CG_BindTexture(r_cg_permutation->fp_Texture_First          , waterplane->texture_camera ? waterplane->texture_camera : r_texture_black);CHECKCGERROR
6132                         if (r_cg_permutation->fp_Texture_Reflection     ) CG_BindTexture(r_cg_permutation->fp_Texture_Reflection     , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);CHECKCGERROR
6133                 }
6134                 else
6135                 {
6136                         if (r_cg_permutation->fp_Texture_Reflection     ) CG_BindTexture(r_cg_permutation->fp_Texture_Reflection     , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);CHECKCGERROR
6137                 }
6138                 if (r_cg_permutation->fp_Texture_ScreenDepth    ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDepth    , r_shadow_prepassgeometrydepthtexture                );CHECKCGERROR
6139                 if (r_cg_permutation->fp_Texture_ScreenNormalMap) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenNormalMap, r_shadow_prepassgeometrynormalmaptexture            );CHECKCGERROR
6140                 if (r_cg_permutation->fp_Texture_ScreenDiffuse  ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDiffuse  , r_shadow_prepasslightingdiffusetexture              );CHECKCGERROR
6141                 if (r_cg_permutation->fp_Texture_ScreenSpecular ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenSpecular , r_shadow_prepasslightingspeculartexture             );CHECKCGERROR
6142                 if (rsurface.rtlight || (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW)))
6143                 {
6144                         if (r_cg_permutation->fp_Texture_ShadowMap2D    ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMap2D    , r_shadow_shadowmap2dtexture                         );CHECKCGERROR
6145                         if (rsurface.rtlight)
6146                         {
6147                                 if (r_cg_permutation->fp_Texture_Cube           ) CG_BindTexture(r_cg_permutation->fp_Texture_Cube           , rsurface.rtlight->currentcubemap                    );CHECKCGERROR
6148                                 if (r_cg_permutation->fp_Texture_CubeProjection ) CG_BindTexture(r_cg_permutation->fp_Texture_CubeProjection , r_shadow_shadowmapvsdcttexture                      );CHECKCGERROR
6149                         }
6150                 }
6151
6152                 CHECKGLERROR
6153 #endif
6154                 break;
6155         case RENDERPATH_GL13:
6156         case RENDERPATH_GL11:
6157                 break;
6158         }
6159 }
6160
6161 void R_SetupShader_DeferredLight(const rtlight_t *rtlight)
6162 {
6163         // select a permutation of the lighting shader appropriate to this
6164         // combination of texture, entity, light source, and fogging, only use the
6165         // minimum features necessary to avoid wasting rendering time in the
6166         // fragment shader on features that are not being used
6167         unsigned int permutation = 0;
6168         unsigned int mode = 0;
6169         const float *lightcolorbase = rtlight->currentcolor;
6170         float ambientscale = rtlight->ambientscale;
6171         float diffusescale = rtlight->diffusescale;
6172         float specularscale = rtlight->specularscale;
6173         // this is the location of the light in view space
6174         vec3_t viewlightorigin;
6175         // this transforms from view space (camera) to light space (cubemap)
6176         matrix4x4_t viewtolight;
6177         matrix4x4_t lighttoview;
6178         float viewtolight16f[16];
6179         float range = 1.0f / r_shadow_deferred_8bitrange.value;
6180         // light source
6181         mode = SHADERMODE_DEFERREDLIGHTSOURCE;
6182         if (rtlight->currentcubemap != r_texture_whitecube)
6183                 permutation |= SHADERPERMUTATION_CUBEFILTER;
6184         if (diffusescale > 0)
6185                 permutation |= SHADERPERMUTATION_DIFFUSE;
6186         if (specularscale > 0)
6187                 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
6188         if (r_shadow_usingshadowmap2d)
6189         {
6190                 permutation |= SHADERPERMUTATION_SHADOWMAP2D;
6191                 if (r_shadow_shadowmapvsdct)
6192                         permutation |= SHADERPERMUTATION_SHADOWMAPVSDCT;
6193
6194                 if (r_shadow_shadowmapsampler)
6195                         permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
6196                 if (r_shadow_shadowmappcf > 1)
6197                         permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
6198                 else if (r_shadow_shadowmappcf)
6199                         permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
6200         }
6201         Matrix4x4_Transform(&r_refdef.view.viewport.viewmatrix, rtlight->shadoworigin, viewlightorigin);
6202         Matrix4x4_Concat(&lighttoview, &r_refdef.view.viewport.viewmatrix, &rtlight->matrix_lighttoworld);
6203         Matrix4x4_Invert_Simple(&viewtolight, &lighttoview);
6204         Matrix4x4_ToArrayFloatGL(&viewtolight, viewtolight16f);
6205         switch(vid.renderpath)
6206         {
6207         case RENDERPATH_D3D9:
6208 #ifdef SUPPORTD3D
6209                 R_SetupShader_SetPermutationHLSL(mode, permutation);
6210                 hlslPSSetParameter3f(D3DPSREGISTER_LightPosition, viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]);
6211                 hlslPSSetParameter16f(D3DPSREGISTER_ViewToLight, viewtolight16f);
6212                 hlslPSSetParameter3f(D3DPSREGISTER_DeferredColor_Ambient , lightcolorbase[0] * ambientscale  * range, lightcolorbase[1] * ambientscale  * range, lightcolorbase[2] * ambientscale  * range);
6213                 hlslPSSetParameter3f(D3DPSREGISTER_DeferredColor_Diffuse , lightcolorbase[0] * diffusescale  * range, lightcolorbase[1] * diffusescale  * range, lightcolorbase[2] * diffusescale  * range);
6214                 hlslPSSetParameter3f(D3DPSREGISTER_DeferredColor_Specular, lightcolorbase[0] * specularscale * range, lightcolorbase[1] * specularscale * range, lightcolorbase[2] * specularscale * range);
6215                 hlslPSSetParameter2f(D3DPSREGISTER_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);
6216                 hlslPSSetParameter4f(D3DPSREGISTER_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);
6217                 hlslPSSetParameter1f(D3DPSREGISTER_SpecularPower, (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * (r_shadow_glossexact.integer ? 0.25f : 1.0f));
6218                 hlslPSSetParameter2f(D3DPSREGISTER_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);
6219                 hlslPSSetParameter2f(D3DPSREGISTER_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);
6220
6221                 R_Mesh_TexBind(GL20TU_ATTENUATION        , r_shadow_attenuationgradienttexture                 );
6222                 R_Mesh_TexBind(GL20TU_SCREENDEPTH        , r_shadow_prepassgeometrydepthcolortexture           );
6223                 R_Mesh_TexBind(GL20TU_SCREENNORMALMAP    , r_shadow_prepassgeometrynormalmaptexture            );
6224                 R_Mesh_TexBind(GL20TU_CUBE               , rsurface.rtlight->currentcubemap                    );
6225                 R_Mesh_TexBind(GL20TU_SHADOWMAP2D        , r_shadow_shadowmap2dcolortexture                    );
6226                 R_Mesh_TexBind(GL20TU_CUBEPROJECTION     , r_shadow_shadowmapvsdcttexture                      );
6227 #endif
6228                 break;
6229         case RENDERPATH_D3D10:
6230                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
6231                 break;
6232         case RENDERPATH_D3D11:
6233                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
6234                 break;
6235         case RENDERPATH_GL20:
6236                 R_SetupShader_SetPermutationGLSL(mode, permutation);
6237                 if (r_glsl_permutation->loc_LightPosition             >= 0) qglUniform3fARB(       r_glsl_permutation->loc_LightPosition            , viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]);
6238                 if (r_glsl_permutation->loc_ViewToLight               >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ViewToLight              , 1, false, viewtolight16f);
6239                 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);
6240                 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);
6241                 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);
6242                 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]);
6243                 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]);
6244                 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) * (r_shadow_glossexact.integer ? 0.25f : 1.0f));
6245                 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]);
6246                 if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
6247
6248                 if (r_glsl_permutation->loc_Texture_Attenuation       >= 0) R_Mesh_TexBind(GL20TU_ATTENUATION        , r_shadow_attenuationgradienttexture                 );
6249                 if (r_glsl_permutation->loc_Texture_ScreenDepth       >= 0) R_Mesh_TexBind(GL20TU_SCREENDEPTH        , r_shadow_prepassgeometrydepthtexture                );
6250                 if (r_glsl_permutation->loc_Texture_ScreenNormalMap   >= 0) R_Mesh_TexBind(GL20TU_SCREENNORMALMAP    , r_shadow_prepassgeometrynormalmaptexture            );
6251                 if (r_glsl_permutation->loc_Texture_Cube              >= 0) R_Mesh_TexBind(GL20TU_CUBE               , rsurface.rtlight->currentcubemap                    );
6252                 if (r_glsl_permutation->loc_Texture_ShadowMap2D       >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAP2D        , r_shadow_shadowmap2dtexture                         );
6253                 if (r_glsl_permutation->loc_Texture_CubeProjection    >= 0) R_Mesh_TexBind(GL20TU_CUBEPROJECTION     , r_shadow_shadowmapvsdcttexture                      );
6254                 break;
6255         case RENDERPATH_CGGL:
6256 #ifdef SUPPORTCG
6257                 R_SetupShader_SetPermutationCG(mode, permutation);
6258                 if (r_cg_permutation->fp_LightPosition            ) cgGLSetParameter3f(r_cg_permutation->fp_LightPosition, viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]);CHECKCGERROR
6259                 if (r_cg_permutation->fp_ViewToLight              ) cgGLSetMatrixParameterfc(r_cg_permutation->fp_ViewToLight, viewtolight16f);CHECKCGERROR
6260                 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
6261                 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
6262                 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
6263                 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
6264                 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
6265                 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) * (r_shadow_glossexact.integer ? 0.25f : 1.0f));CHECKCGERROR
6266                 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
6267                 if (r_cg_permutation->fp_PixelToScreenTexCoord    ) cgGLSetParameter2f(r_cg_permutation->fp_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);CHECKCGERROR
6268
6269                 if (r_cg_permutation->fp_Texture_Attenuation      ) CG_BindTexture(r_cg_permutation->fp_Texture_Attenuation    , r_shadow_attenuationgradienttexture                 );CHECKCGERROR
6270                 if (r_cg_permutation->fp_Texture_ScreenDepth      ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDepth    , r_shadow_prepassgeometrydepthtexture                );CHECKCGERROR
6271                 if (r_cg_permutation->fp_Texture_ScreenNormalMap  ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenNormalMap, r_shadow_prepassgeometrynormalmaptexture            );CHECKCGERROR
6272                 if (r_cg_permutation->fp_Texture_Cube             ) CG_BindTexture(r_cg_permutation->fp_Texture_Cube           , rsurface.rtlight->currentcubemap                    );CHECKCGERROR
6273                 if (r_cg_permutation->fp_Texture_ShadowMap2D      ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMap2D    , r_shadow_shadowmap2dtexture                         );CHECKCGERROR
6274                 if (r_cg_permutation->fp_Texture_CubeProjection   ) CG_BindTexture(r_cg_permutation->fp_Texture_CubeProjection , r_shadow_shadowmapvsdcttexture                      );CHECKCGERROR
6275 #endif
6276                 break;
6277         case RENDERPATH_GL13:
6278         case RENDERPATH_GL11:
6279                 break;
6280         }
6281 }
6282
6283 #define SKINFRAME_HASH 1024
6284
6285 typedef struct
6286 {
6287         int loadsequence; // incremented each level change
6288         memexpandablearray_t array;
6289         skinframe_t *hash[SKINFRAME_HASH];
6290 }
6291 r_skinframe_t;
6292 r_skinframe_t r_skinframe;
6293
6294 void R_SkinFrame_PrepareForPurge(void)
6295 {
6296         r_skinframe.loadsequence++;
6297         // wrap it without hitting zero
6298         if (r_skinframe.loadsequence >= 200)
6299                 r_skinframe.loadsequence = 1;
6300 }
6301
6302 void R_SkinFrame_MarkUsed(skinframe_t *skinframe)
6303 {
6304         if (!skinframe)
6305                 return;
6306         // mark the skinframe as used for the purging code
6307         skinframe->loadsequence = r_skinframe.loadsequence;
6308 }
6309
6310 void R_SkinFrame_Purge(void)
6311 {
6312         int i;
6313         skinframe_t *s;
6314         for (i = 0;i < SKINFRAME_HASH;i++)
6315         {
6316                 for (s = r_skinframe.hash[i];s;s = s->next)
6317                 {
6318                         if (s->loadsequence && s->loadsequence != r_skinframe.loadsequence)
6319                         {
6320                                 if (s->merged == s->base)
6321                                         s->merged = NULL;
6322                                 // FIXME: maybe pass a pointer to the pointer to R_PurgeTexture and reset it to NULL inside? [11/29/2007 Black]
6323                                 R_PurgeTexture(s->stain );s->stain  = NULL;
6324                                 R_PurgeTexture(s->merged);s->merged = NULL;
6325                                 R_PurgeTexture(s->base  );s->base   = NULL;
6326                                 R_PurgeTexture(s->pants );s->pants  = NULL;
6327                                 R_PurgeTexture(s->shirt );s->shirt  = NULL;
6328                                 R_PurgeTexture(s->nmap  );s->nmap   = NULL;
6329                                 R_PurgeTexture(s->gloss );s->gloss  = NULL;
6330                                 R_PurgeTexture(s->glow  );s->glow   = NULL;
6331                                 R_PurgeTexture(s->fog   );s->fog    = NULL;
6332                                 R_PurgeTexture(s->reflect);s->reflect = NULL;
6333                                 s->loadsequence = 0;
6334                         }
6335                 }
6336         }
6337 }
6338
6339 skinframe_t *R_SkinFrame_FindNextByName( skinframe_t *last, const char *name ) {
6340         skinframe_t *item;
6341         char basename[MAX_QPATH];
6342
6343         Image_StripImageExtension(name, basename, sizeof(basename));
6344
6345         if( last == NULL ) {
6346                 int hashindex;
6347                 hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
6348                 item = r_skinframe.hash[hashindex];
6349         } else {
6350                 item = last->next;
6351         }
6352
6353         // linearly search through the hash bucket
6354         for( ; item ; item = item->next ) {
6355                 if( !strcmp( item->basename, basename ) ) {
6356                         return item;
6357                 }
6358         }
6359         return NULL;
6360 }
6361
6362 skinframe_t *R_SkinFrame_Find(const char *name, int textureflags, int comparewidth, int compareheight, int comparecrc, qboolean add)
6363 {
6364         skinframe_t *item;
6365         int hashindex;
6366         char basename[MAX_QPATH];
6367
6368         Image_StripImageExtension(name, basename, sizeof(basename));
6369
6370         hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
6371         for (item = r_skinframe.hash[hashindex];item;item = item->next)
6372                 if (!strcmp(item->basename, basename) && item->textureflags == textureflags && item->comparewidth == comparewidth && item->compareheight == compareheight && item->comparecrc == comparecrc)
6373                         break;
6374
6375         if (!item) {
6376                 rtexture_t *dyntexture;
6377                 // check whether its a dynamic texture
6378                 dyntexture = CL_GetDynTexture( basename );
6379                 if (!add && !dyntexture)
6380                         return NULL;
6381                 item = (skinframe_t *)Mem_ExpandableArray_AllocRecord(&r_skinframe.array);
6382                 memset(item, 0, sizeof(*item));
6383                 strlcpy(item->basename, basename, sizeof(item->basename));
6384                 item->base = dyntexture; // either NULL or dyntexture handle
6385                 item->textureflags = textureflags;
6386                 item->comparewidth = comparewidth;
6387                 item->compareheight = compareheight;
6388                 item->comparecrc = comparecrc;
6389                 item->next = r_skinframe.hash[hashindex];
6390                 r_skinframe.hash[hashindex] = item;
6391         }
6392         else if( item->base == NULL )
6393         {
6394                 rtexture_t *dyntexture;
6395                 // check whether its a dynamic texture
6396                 // 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]
6397                 dyntexture = CL_GetDynTexture( basename );
6398                 item->base = dyntexture; // either NULL or dyntexture handle
6399         }
6400
6401         R_SkinFrame_MarkUsed(item);
6402         return item;
6403 }
6404
6405 #define R_SKINFRAME_LOAD_AVERAGE_COLORS(cnt, getpixel) \
6406         { \
6407                 unsigned long long avgcolor[5], wsum; \
6408                 int pix, comp, w; \
6409                 avgcolor[0] = 0; \
6410                 avgcolor[1] = 0; \
6411                 avgcolor[2] = 0; \
6412                 avgcolor[3] = 0; \
6413                 avgcolor[4] = 0; \
6414                 wsum = 0; \
6415                 for(pix = 0; pix < cnt; ++pix) \
6416                 { \
6417                         w = 0; \
6418                         for(comp = 0; comp < 3; ++comp) \
6419                                 w += getpixel; \
6420                         if(w) /* ignore perfectly black pixels because that is better for model skins */ \
6421                         { \
6422                                 ++wsum; \
6423                                 /* comp = 3; -- not needed, comp is always 3 when we get here */ \
6424                                 w = getpixel; \
6425                                 for(comp = 0; comp < 3; ++comp) \
6426                                         avgcolor[comp] += getpixel * w; \
6427                                 avgcolor[3] += w; \
6428                         } \
6429                         /* comp = 3; -- not needed, comp is always 3 when we get here */ \
6430                         avgcolor[4] += getpixel; \
6431                 } \
6432                 if(avgcolor[3] == 0) /* no pixels seen? even worse */ \
6433                         avgcolor[3] = 1; \
6434                 skinframe->avgcolor[0] = avgcolor[2] / (255.0 * avgcolor[3]); \
6435                 skinframe->avgcolor[1] = avgcolor[1] / (255.0 * avgcolor[3]); \
6436                 skinframe->avgcolor[2] = avgcolor[0] / (255.0 * avgcolor[3]); \
6437                 skinframe->avgcolor[3] = avgcolor[4] / (255.0 * cnt); \
6438         }
6439
6440 extern cvar_t gl_picmip;
6441 skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboolean complain)
6442 {
6443         int j;
6444         unsigned char *pixels;
6445         unsigned char *bumppixels;
6446         unsigned char *basepixels = NULL;
6447         int basepixels_width = 0;
6448         int basepixels_height = 0;
6449         skinframe_t *skinframe;
6450         rtexture_t *ddsbase = NULL;
6451         qboolean ddshasalpha = false;
6452         float ddsavgcolor[4];
6453         char basename[MAX_QPATH];
6454         int miplevel = R_PicmipForFlags(textureflags);
6455         int savemiplevel = miplevel;
6456         int mymiplevel;
6457
6458         if (cls.state == ca_dedicated)
6459                 return NULL;
6460
6461         // return an existing skinframe if already loaded
6462         // if loading of the first image fails, don't make a new skinframe as it
6463         // would cause all future lookups of this to be missing
6464         skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
6465         if (skinframe && skinframe->base)
6466                 return skinframe;
6467
6468         Image_StripImageExtension(name, basename, sizeof(basename));
6469
6470         // check for DDS texture file first
6471         if (!r_loaddds || !(ddsbase = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s.dds", basename), textureflags, &ddshasalpha, ddsavgcolor, miplevel)))
6472         {
6473                 basepixels = loadimagepixelsbgra(name, complain, true, r_texture_convertsRGB_skin.integer != 0, &miplevel);
6474                 if (basepixels == NULL)
6475                         return NULL;
6476         }
6477
6478         // FIXME handle miplevel
6479
6480         if (developer_loading.integer)
6481                 Con_Printf("loading skin \"%s\"\n", name);
6482
6483         // we've got some pixels to store, so really allocate this new texture now
6484         if (!skinframe)
6485                 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, true);
6486         skinframe->stain = NULL;
6487         skinframe->merged = NULL;
6488         skinframe->base = NULL;
6489         skinframe->pants = NULL;
6490         skinframe->shirt = NULL;
6491         skinframe->nmap = NULL;
6492         skinframe->gloss = NULL;
6493         skinframe->glow = NULL;
6494         skinframe->fog = NULL;
6495         skinframe->reflect = NULL;
6496         skinframe->hasalpha = false;
6497
6498         if (ddsbase)
6499         {
6500                 skinframe->base = ddsbase;
6501                 skinframe->hasalpha = ddshasalpha;
6502                 VectorCopy(ddsavgcolor, skinframe->avgcolor);
6503                 if (r_loadfog && skinframe->hasalpha)
6504                         skinframe->fog = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_mask.dds", skinframe->basename), textureflags | TEXF_ALPHA, NULL, NULL, miplevel);
6505                 //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]);
6506         }
6507         else
6508         {
6509                 basepixels_width = image_width;
6510                 basepixels_height = image_height;
6511                 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);
6512                 if (textureflags & TEXF_ALPHA)
6513                 {
6514                         for (j = 3;j < basepixels_width * basepixels_height * 4;j += 4)
6515                         {
6516                                 if (basepixels[j] < 255)
6517                                 {
6518                                         skinframe->hasalpha = true;
6519                                         break;
6520                                 }
6521                         }
6522                         if (r_loadfog && skinframe->hasalpha)
6523                         {
6524                                 // has transparent pixels
6525                                 pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
6526                                 for (j = 0;j < image_width * image_height * 4;j += 4)
6527                                 {
6528                                         pixels[j+0] = 255;
6529                                         pixels[j+1] = 255;
6530                                         pixels[j+2] = 255;
6531                                         pixels[j+3] = basepixels[j+3];
6532                                 }
6533                                 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);
6534                                 Mem_Free(pixels);
6535                         }
6536                 }
6537                 R_SKINFRAME_LOAD_AVERAGE_COLORS(basepixels_width * basepixels_height, basepixels[4 * pix + comp]);
6538                 //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]);
6539                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->base)
6540                         R_SaveTextureDDSFile(skinframe->base, va("dds/%s.dds", skinframe->basename), true, skinframe->hasalpha);
6541                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->fog)
6542                         R_SaveTextureDDSFile(skinframe->fog, va("dds/%s_mask.dds", skinframe->basename), true, true);
6543         }
6544
6545         if (r_loaddds)
6546         {
6547                 mymiplevel = savemiplevel;
6548                 if (r_loadnormalmap)
6549                         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);
6550                 skinframe->glow = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_glow.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel);
6551                 if (r_loadgloss)
6552                         skinframe->gloss = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_gloss.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel);
6553                 skinframe->pants = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_pants.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel);
6554                 skinframe->shirt = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_shirt.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel);
6555                 skinframe->reflect = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_reflect.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel);
6556         }
6557
6558         // _norm is the name used by tenebrae and has been adopted as standard
6559         if (r_loadnormalmap && skinframe->nmap == NULL)
6560         {
6561                 mymiplevel = savemiplevel;
6562                 if ((pixels = loadimagepixelsbgra(va("%s_norm", skinframe->basename), false, false, false, &mymiplevel)) != NULL)
6563                 {
6564                         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);
6565                         Mem_Free(pixels);
6566                         pixels = NULL;
6567                 }
6568                 else if (r_shadow_bumpscale_bumpmap.value > 0 && (bumppixels = loadimagepixelsbgra(va("%s_bump", skinframe->basename), false, false, false, &mymiplevel)) != NULL)
6569                 {
6570                         pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
6571                         Image_HeightmapToNormalmap_BGRA(bumppixels, pixels, image_width, image_height, false, r_shadow_bumpscale_bumpmap.value);
6572                         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);
6573                         Mem_Free(pixels);
6574                         Mem_Free(bumppixels);
6575                 }
6576                 else if (r_shadow_bumpscale_basetexture.value > 0)
6577                 {
6578                         pixels = (unsigned char *)Mem_Alloc(tempmempool, basepixels_width * basepixels_height * 4);
6579                         Image_HeightmapToNormalmap_BGRA(basepixels, pixels, basepixels_width, basepixels_height, false, r_shadow_bumpscale_basetexture.value);
6580                         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);
6581                         Mem_Free(pixels);
6582                 }
6583                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->nmap)
6584                         R_SaveTextureDDSFile(skinframe->nmap, va("dds/%s_norm.dds", skinframe->basename), true, true);
6585         }
6586
6587         // _luma is supported only for tenebrae compatibility
6588         // _glow is the preferred name
6589         mymiplevel = savemiplevel;
6590         if (skinframe->glow == NULL && ((pixels = loadimagepixelsbgra(va("%s_glow",  skinframe->basename), false, false, r_texture_convertsRGB_skin.integer != 0, &mymiplevel)) || (pixels = loadimagepixelsbgra(va("%s_luma", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer != 0, &mymiplevel))))
6591         {
6592                 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);
6593                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->glow)
6594                         R_SaveTextureDDSFile(skinframe->glow, va("dds/%s_glow.dds", skinframe->basename), true, true);
6595                 Mem_Free(pixels);pixels = NULL;
6596         }
6597
6598         mymiplevel = savemiplevel;
6599         if (skinframe->gloss == NULL && r_loadgloss && (pixels = loadimagepixelsbgra(va("%s_gloss", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer != 0, &mymiplevel)))
6600         {
6601                 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);
6602                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->gloss)
6603                         R_SaveTextureDDSFile(skinframe->gloss, va("dds/%s_gloss.dds", skinframe->basename), true, true);
6604                 Mem_Free(pixels);
6605                 pixels = NULL;
6606         }
6607
6608         mymiplevel = savemiplevel;
6609         if (skinframe->pants == NULL && (pixels = loadimagepixelsbgra(va("%s_pants", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer != 0, &mymiplevel)))
6610         {
6611                 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);
6612                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->pants)
6613                         R_SaveTextureDDSFile(skinframe->pants, va("dds/%s_pants.dds", skinframe->basename), true, false);
6614                 Mem_Free(pixels);
6615                 pixels = NULL;
6616         }
6617
6618         mymiplevel = savemiplevel;
6619         if (skinframe->shirt == NULL && (pixels = loadimagepixelsbgra(va("%s_shirt", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer != 0, &mymiplevel)))
6620         {
6621                 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);
6622                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->shirt)
6623                         R_SaveTextureDDSFile(skinframe->shirt, va("dds/%s_shirt.dds", skinframe->basename), true, false);
6624                 Mem_Free(pixels);
6625                 pixels = NULL;
6626         }
6627
6628         mymiplevel = savemiplevel;
6629         if (skinframe->reflect == NULL && (pixels = loadimagepixelsbgra(va("%s_reflect", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer != 0, &mymiplevel)))
6630         {
6631                 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);
6632                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->reflect)
6633                         R_SaveTextureDDSFile(skinframe->reflect, va("dds/%s_reflect.dds", skinframe->basename), true, true);
6634                 Mem_Free(pixels);
6635                 pixels = NULL;
6636         }
6637
6638         if (basepixels)
6639                 Mem_Free(basepixels);
6640
6641         return skinframe;
6642 }
6643
6644 // this is only used by .spr32 sprites, HL .spr files, HL .bsp files
6645 skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, const unsigned char *skindata, int width, int height)
6646 {
6647         int i;
6648         unsigned char *temp1, *temp2;
6649         skinframe_t *skinframe;
6650
6651         if (cls.state == ca_dedicated)
6652                 return NULL;
6653
6654         // if already loaded just return it, otherwise make a new skinframe
6655         skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height*4) : 0, true);
6656         if (skinframe && skinframe->base)
6657                 return skinframe;
6658
6659         skinframe->stain = NULL;
6660         skinframe->merged = NULL;
6661         skinframe->base = NULL;
6662         skinframe->pants = NULL;
6663         skinframe->shirt = NULL;
6664         skinframe->nmap = NULL;
6665         skinframe->gloss = NULL;
6666         skinframe->glow = NULL;
6667         skinframe->fog = NULL;
6668         skinframe->reflect = NULL;
6669         skinframe->hasalpha = false;
6670
6671         // if no data was provided, then clearly the caller wanted to get a blank skinframe
6672         if (!skindata)
6673                 return NULL;
6674
6675         if (developer_loading.integer)
6676                 Con_Printf("loading 32bit skin \"%s\"\n", name);
6677
6678         if (r_loadnormalmap && r_shadow_bumpscale_basetexture.value > 0)
6679         {
6680                 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
6681                 temp2 = temp1 + width * height * 4;
6682                 Image_HeightmapToNormalmap_BGRA(skindata, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
6683                 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);
6684                 Mem_Free(temp1);
6685         }
6686         skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_BGRA, textureflags, -1, NULL);
6687         if (textureflags & TEXF_ALPHA)
6688         {
6689                 for (i = 3;i < width * height * 4;i += 4)
6690                 {
6691                         if (skindata[i] < 255)
6692                         {
6693                                 skinframe->hasalpha = true;
6694                                 break;
6695                         }
6696                 }
6697                 if (r_loadfog && skinframe->hasalpha)
6698                 {
6699                         unsigned char *fogpixels = (unsigned char *)Mem_Alloc(tempmempool, width * height * 4);
6700                         memcpy(fogpixels, skindata, width * height * 4);
6701                         for (i = 0;i < width * height * 4;i += 4)
6702                                 fogpixels[i] = fogpixels[i+1] = fogpixels[i+2] = 255;
6703                         skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, fogpixels, TEXTYPE_BGRA, textureflags, -1, NULL);
6704                         Mem_Free(fogpixels);
6705                 }
6706         }
6707
6708         R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, skindata[4 * pix + comp]);
6709         //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]);
6710
6711         return skinframe;
6712 }
6713
6714 skinframe_t *R_SkinFrame_LoadInternalQuake(const char *name, int textureflags, int loadpantsandshirt, int loadglowtexture, const unsigned char *skindata, int width, int height)
6715 {
6716         int i;
6717         int featuresmask;
6718         skinframe_t *skinframe;
6719
6720         if (cls.state == ca_dedicated)
6721                 return NULL;
6722
6723         // if already loaded just return it, otherwise make a new skinframe
6724         skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height) : 0, true);
6725         if (skinframe && skinframe->base)
6726                 return skinframe;
6727
6728         skinframe->stain = NULL;
6729         skinframe->merged = NULL;
6730         skinframe->base = NULL;
6731         skinframe->pants = NULL;
6732         skinframe->shirt = NULL;
6733         skinframe->nmap = NULL;
6734         skinframe->gloss = NULL;
6735         skinframe->glow = NULL;
6736         skinframe->fog = NULL;
6737         skinframe->reflect = NULL;
6738         skinframe->hasalpha = false;
6739
6740         // if no data was provided, then clearly the caller wanted to get a blank skinframe
6741         if (!skindata)
6742                 return NULL;
6743
6744         if (developer_loading.integer)
6745                 Con_Printf("loading quake skin \"%s\"\n", name);
6746
6747         // 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)
6748         skinframe->qpixels = (unsigned char *)Mem_Alloc(r_main_mempool, width*height);
6749         memcpy(skinframe->qpixels, skindata, width*height);
6750         skinframe->qwidth = width;
6751         skinframe->qheight = height;
6752
6753         featuresmask = 0;
6754         for (i = 0;i < width * height;i++)
6755                 featuresmask |= palette_featureflags[skindata[i]];
6756
6757         skinframe->hasalpha = false;
6758         skinframe->qhascolormapping = loadpantsandshirt && (featuresmask & (PALETTEFEATURE_PANTS | PALETTEFEATURE_SHIRT));
6759         skinframe->qgeneratenmap = r_shadow_bumpscale_basetexture.value > 0;
6760         skinframe->qgeneratemerged = true;
6761         skinframe->qgeneratebase = skinframe->qhascolormapping;
6762         skinframe->qgenerateglow = loadglowtexture && (featuresmask & PALETTEFEATURE_GLOW);
6763
6764         R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, ((unsigned char *)palette_bgra_complete)[skindata[pix]*4 + comp]);
6765         //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]);
6766
6767         return skinframe;
6768 }
6769
6770 static void R_SkinFrame_GenerateTexturesFromQPixels(skinframe_t *skinframe, qboolean colormapped)
6771 {
6772         int width;
6773         int height;
6774         unsigned char *skindata;
6775
6776         if (!skinframe->qpixels)
6777                 return;
6778
6779         if (!skinframe->qhascolormapping)
6780                 colormapped = false;
6781
6782         if (colormapped)
6783         {
6784                 if (!skinframe->qgeneratebase)
6785                         return;
6786         }
6787         else
6788         {
6789                 if (!skinframe->qgeneratemerged)
6790                         return;
6791         }
6792
6793         width = skinframe->qwidth;
6794         height = skinframe->qheight;
6795         skindata = skinframe->qpixels;
6796
6797         if (skinframe->qgeneratenmap)
6798         {
6799                 unsigned char *temp1, *temp2;
6800                 skinframe->qgeneratenmap = false;
6801                 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
6802                 temp2 = temp1 + width * height * 4;
6803                 // use either a custom palette or the quake palette
6804                 Image_Copy8bitBGRA(skindata, temp1, width * height, palette_bgra_complete);
6805                 Image_HeightmapToNormalmap_BGRA(temp1, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
6806                 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);
6807                 Mem_Free(temp1);
6808         }
6809
6810         if (skinframe->qgenerateglow)
6811         {
6812                 skinframe->qgenerateglow = false;
6813                 skinframe->glow = R_LoadTexture2D(r_main_texturepool, va("%s_glow", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, -1, palette_bgra_onlyfullbrights); // glow
6814         }
6815
6816         if (colormapped)
6817         {
6818                 skinframe->qgeneratebase = false;
6819                 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);
6820                 skinframe->pants = R_LoadTexture2D(r_main_texturepool, va("%s_pants", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, -1, palette_bgra_pantsaswhite);
6821                 skinframe->shirt = R_LoadTexture2D(r_main_texturepool, va("%s_shirt", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, -1, palette_bgra_shirtaswhite);
6822         }
6823         else
6824         {
6825                 skinframe->qgeneratemerged = false;
6826                 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);
6827         }
6828
6829         if (!skinframe->qgeneratemerged && !skinframe->qgeneratebase)
6830         {
6831                 Mem_Free(skinframe->qpixels);
6832                 skinframe->qpixels = NULL;
6833         }
6834 }
6835
6836 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)
6837 {
6838         int i;
6839         skinframe_t *skinframe;
6840
6841         if (cls.state == ca_dedicated)
6842                 return NULL;
6843
6844         // if already loaded just return it, otherwise make a new skinframe
6845         skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height) : 0, true);
6846         if (skinframe && skinframe->base)
6847                 return skinframe;
6848
6849         skinframe->stain = NULL;
6850         skinframe->merged = NULL;
6851         skinframe->base = NULL;
6852         skinframe->pants = NULL;
6853         skinframe->shirt = NULL;
6854         skinframe->nmap = NULL;
6855         skinframe->gloss = NULL;
6856         skinframe->glow = NULL;
6857         skinframe->fog = NULL;
6858         skinframe->reflect = NULL;
6859         skinframe->hasalpha = false;
6860
6861         // if no data was provided, then clearly the caller wanted to get a blank skinframe
6862         if (!skindata)
6863                 return NULL;
6864
6865         if (developer_loading.integer)
6866                 Con_Printf("loading embedded 8bit image \"%s\"\n", name);
6867
6868         skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_PALETTE, textureflags, -1, palette);
6869         if (textureflags & TEXF_ALPHA)
6870         {
6871                 for (i = 0;i < width * height;i++)
6872                 {
6873                         if (((unsigned char *)palette)[skindata[i]*4+3] < 255)
6874                         {
6875                                 skinframe->hasalpha = true;
6876                                 break;
6877                         }
6878                 }
6879                 if (r_loadfog && skinframe->hasalpha)
6880                         skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, textureflags, -1, alphapalette);
6881         }
6882
6883         R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, ((unsigned char *)palette)[skindata[pix]*4 + comp]);
6884         //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]);
6885
6886         return skinframe;
6887 }
6888
6889 skinframe_t *R_SkinFrame_LoadMissing(void)
6890 {
6891         skinframe_t *skinframe;
6892
6893         if (cls.state == ca_dedicated)
6894                 return NULL;
6895
6896         skinframe = R_SkinFrame_Find("missing", TEXF_FORCENEAREST, 0, 0, 0, true);
6897         skinframe->stain = NULL;
6898         skinframe->merged = NULL;
6899         skinframe->base = NULL;
6900         skinframe->pants = NULL;
6901         skinframe->shirt = NULL;
6902         skinframe->nmap = NULL;
6903         skinframe->gloss = NULL;
6904         skinframe->glow = NULL;
6905         skinframe->fog = NULL;
6906         skinframe->reflect = NULL;
6907         skinframe->hasalpha = false;
6908
6909         skinframe->avgcolor[0] = rand() / RAND_MAX;
6910         skinframe->avgcolor[1] = rand() / RAND_MAX;
6911         skinframe->avgcolor[2] = rand() / RAND_MAX;
6912         skinframe->avgcolor[3] = 1;
6913
6914         return skinframe;
6915 }
6916
6917 //static char *suffix[6] = {"ft", "bk", "rt", "lf", "up", "dn"};
6918 typedef struct suffixinfo_s
6919 {
6920         const char *suffix;
6921         qboolean flipx, flipy, flipdiagonal;
6922 }
6923 suffixinfo_t;
6924 static suffixinfo_t suffix[3][6] =
6925 {
6926         {
6927                 {"px",   false, false, false},
6928                 {"nx",   false, false, false},
6929                 {"py",   false, false, false},
6930                 {"ny",   false, false, false},
6931                 {"pz",   false, false, false},
6932                 {"nz",   false, false, false}
6933         },
6934         {
6935                 {"posx", false, false, false},
6936                 {"negx", false, false, false},
6937                 {"posy", false, false, false},
6938                 {"negy", false, false, false},
6939                 {"posz", false, false, false},
6940                 {"negz", false, false, false}
6941         },
6942         {
6943                 {"rt",    true, false,  true},
6944                 {"lf",   false,  true,  true},
6945                 {"ft",    true,  true, false},
6946                 {"bk",   false, false, false},
6947                 {"up",    true, false,  true},
6948                 {"dn",    true, false,  true}
6949         }
6950 };
6951
6952 static int componentorder[4] = {0, 1, 2, 3};
6953
6954 rtexture_t *R_LoadCubemap(const char *basename)
6955 {
6956         int i, j, cubemapsize;
6957         unsigned char *cubemappixels, *image_buffer;
6958         rtexture_t *cubemaptexture;
6959         char name[256];
6960         // must start 0 so the first loadimagepixels has no requested width/height
6961         cubemapsize = 0;
6962         cubemappixels = NULL;
6963         cubemaptexture = NULL;
6964         // keep trying different suffix groups (posx, px, rt) until one loads
6965         for (j = 0;j < 3 && !cubemappixels;j++)
6966         {
6967                 // load the 6 images in the suffix group
6968                 for (i = 0;i < 6;i++)
6969                 {
6970                         // generate an image name based on the base and and suffix
6971                         dpsnprintf(name, sizeof(name), "%s%s", basename, suffix[j][i].suffix);
6972                         // load it
6973                         if ((image_buffer = loadimagepixelsbgra(name, false, false, r_texture_convertsRGB_cubemap.integer != 0, NULL)))
6974                         {
6975                                 // an image loaded, make sure width and height are equal
6976                                 if (image_width == image_height && (!cubemappixels || image_width == cubemapsize))
6977                                 {
6978                                         // if this is the first image to load successfully, allocate the cubemap memory
6979                                         if (!cubemappixels && image_width >= 1)
6980                                         {
6981                                                 cubemapsize = image_width;
6982                                                 // note this clears to black, so unavailable sides are black
6983                                                 cubemappixels = (unsigned char *)Mem_Alloc(tempmempool, 6*cubemapsize*cubemapsize*4);
6984                                         }
6985                                         // copy the image with any flipping needed by the suffix (px and posx types don't need flipping)
6986                                         if (cubemappixels)
6987                                                 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);
6988                                 }
6989                                 else
6990                                         Con_Printf("Cubemap image \"%s\" (%ix%i) is not square, OpenGL requires square cubemaps.\n", name, image_width, image_height);
6991                                 // free the image
6992                                 Mem_Free(image_buffer);
6993                         }
6994                 }
6995         }
6996         // if a cubemap loaded, upload it
6997         if (cubemappixels)
6998         {
6999                 if (developer_loading.integer)
7000                         Con_Printf("loading cubemap \"%s\"\n", basename);
7001
7002                 cubemaptexture = R_LoadTextureCubeMap(r_main_texturepool, basename, cubemapsize, cubemappixels, TEXTYPE_BGRA, (gl_texturecompression_lightcubemaps.integer ? TEXF_COMPRESS : 0) | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
7003                 Mem_Free(cubemappixels);
7004         }
7005         else
7006         {
7007                 Con_DPrintf("failed to load cubemap \"%s\"\n", basename);
7008                 if (developer_loading.integer)
7009                 {
7010                         Con_Printf("(tried tried images ");
7011                         for (j = 0;j < 3;j++)
7012                                 for (i = 0;i < 6;i++)
7013                                         Con_Printf("%s\"%s%s.tga\"", j + i > 0 ? ", " : "", basename, suffix[j][i].suffix);
7014                         Con_Print(" and was unable to find any of them).\n");
7015                 }
7016         }
7017         return cubemaptexture;
7018 }
7019
7020 rtexture_t *R_GetCubemap(const char *basename)
7021 {
7022         int i;
7023         for (i = 0;i < r_texture_numcubemaps;i++)
7024                 if (!strcasecmp(r_texture_cubemaps[i].basename, basename))
7025                         return r_texture_cubemaps[i].texture ? r_texture_cubemaps[i].texture : r_texture_whitecube;
7026         if (i >= MAX_CUBEMAPS)
7027                 return r_texture_whitecube;
7028         r_texture_numcubemaps++;
7029         strlcpy(r_texture_cubemaps[i].basename, basename, sizeof(r_texture_cubemaps[i].basename));
7030         r_texture_cubemaps[i].texture = R_LoadCubemap(r_texture_cubemaps[i].basename);
7031         return r_texture_cubemaps[i].texture;
7032 }
7033
7034 void R_FreeCubemaps(void)
7035 {
7036         int i;
7037         for (i = 0;i < r_texture_numcubemaps;i++)
7038         {
7039                 if (developer_loading.integer)
7040                         Con_DPrintf("unloading cubemap \"%s\"\n", r_texture_cubemaps[i].basename);
7041                 if (r_texture_cubemaps[i].texture)
7042                         R_FreeTexture(r_texture_cubemaps[i].texture);
7043         }
7044         r_texture_numcubemaps = 0;
7045 }
7046
7047 void R_Main_FreeViewCache(void)
7048 {
7049         if (r_refdef.viewcache.entityvisible)
7050                 Mem_Free(r_refdef.viewcache.entityvisible);
7051         if (r_refdef.viewcache.world_pvsbits)
7052                 Mem_Free(r_refdef.viewcache.world_pvsbits);
7053         if (r_refdef.viewcache.world_leafvisible)
7054                 Mem_Free(r_refdef.viewcache.world_leafvisible);
7055         if (r_refdef.viewcache.world_surfacevisible)
7056                 Mem_Free(r_refdef.viewcache.world_surfacevisible);
7057         memset(&r_refdef.viewcache, 0, sizeof(r_refdef.viewcache));
7058 }
7059
7060 void R_Main_ResizeViewCache(void)
7061 {
7062         int numentities = r_refdef.scene.numentities;
7063         int numclusters = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_pvsclusters : 1;
7064         int numclusterbytes = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_pvsclusterbytes : 1;
7065         int numleafs = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_leafs : 1;
7066         int numsurfaces = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->num_surfaces : 1;
7067         if (r_refdef.viewcache.maxentities < numentities)
7068         {
7069                 r_refdef.viewcache.maxentities = numentities;
7070                 if (r_refdef.viewcache.entityvisible)
7071                         Mem_Free(r_refdef.viewcache.entityvisible);
7072                 r_refdef.viewcache.entityvisible = (unsigned char *)Mem_Alloc(r_main_mempool, r_refdef.viewcache.maxentities);
7073         }
7074         if (r_refdef.viewcache.world_numclusters != numclusters)
7075         {
7076                 r_refdef.viewcache.world_numclusters = numclusters;
7077                 r_refdef.viewcache.world_numclusterbytes = numclusterbytes;
7078                 if (r_refdef.viewcache.world_pvsbits)
7079                         Mem_Free(r_refdef.viewcache.world_pvsbits);
7080                 r_refdef.viewcache.world_pvsbits = (unsigned char *)Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numclusterbytes);
7081         }
7082         if (r_refdef.viewcache.world_numleafs != numleafs)
7083         {
7084                 r_refdef.viewcache.world_numleafs = numleafs;
7085                 if (r_refdef.viewcache.world_leafvisible)
7086                         Mem_Free(r_refdef.viewcache.world_leafvisible);
7087                 r_refdef.viewcache.world_leafvisible = (unsigned char *)Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numleafs);
7088         }
7089         if (r_refdef.viewcache.world_numsurfaces != numsurfaces)
7090         {
7091                 r_refdef.viewcache.world_numsurfaces = numsurfaces;
7092                 if (r_refdef.viewcache.world_surfacevisible)
7093                         Mem_Free(r_refdef.viewcache.world_surfacevisible);
7094                 r_refdef.viewcache.world_surfacevisible = (unsigned char *)Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numsurfaces);
7095         }
7096 }
7097
7098 extern rtexture_t *loadingscreentexture;
7099 void gl_main_start(void)
7100 {
7101         loadingscreentexture = NULL;
7102         r_texture_blanknormalmap = NULL;
7103         r_texture_white = NULL;
7104         r_texture_grey128 = NULL;
7105         r_texture_black = NULL;
7106         r_texture_whitecube = NULL;
7107         r_texture_normalizationcube = NULL;
7108         r_texture_fogattenuation = NULL;
7109         r_texture_fogheighttexture = NULL;
7110         r_texture_gammaramps = NULL;
7111         r_texture_numcubemaps = 0;
7112
7113         r_loaddds = vid.support.arb_texture_compression && vid.support.ext_texture_compression_s3tc && r_texture_dds_load.integer;
7114         r_savedds = vid.support.arb_texture_compression && vid.support.ext_texture_compression_s3tc && r_texture_dds_save.integer;
7115
7116         switch(vid.renderpath)
7117         {
7118         case RENDERPATH_GL20:
7119         case RENDERPATH_CGGL:
7120         case RENDERPATH_D3D9:
7121         case RENDERPATH_D3D10:
7122         case RENDERPATH_D3D11:
7123                 Cvar_SetValueQuick(&r_textureunits, vid.texunits);
7124                 Cvar_SetValueQuick(&gl_combine, 1);
7125                 Cvar_SetValueQuick(&r_glsl, 1);
7126                 r_loadnormalmap = true;
7127                 r_loadgloss = true;
7128                 r_loadfog = false;
7129                 break;
7130         case RENDERPATH_GL13:
7131                 Cvar_SetValueQuick(&r_textureunits, vid.texunits);
7132                 Cvar_SetValueQuick(&gl_combine, 1);
7133                 Cvar_SetValueQuick(&r_glsl, 0);
7134                 r_loadnormalmap = false;
7135                 r_loadgloss = false;
7136                 r_loadfog = true;
7137                 break;
7138         case RENDERPATH_GL11:
7139                 Cvar_SetValueQuick(&r_textureunits, vid.texunits);
7140                 Cvar_SetValueQuick(&gl_combine, 0);
7141                 Cvar_SetValueQuick(&r_glsl, 0);
7142                 r_loadnormalmap = false;
7143                 r_loadgloss = false;
7144                 r_loadfog = true;
7145                 break;
7146         }
7147
7148         R_AnimCache_Free();
7149         R_FrameData_Reset();
7150
7151         r_numqueries = 0;
7152         r_maxqueries = 0;
7153         memset(r_queries, 0, sizeof(r_queries));
7154
7155         r_qwskincache = NULL;
7156         r_qwskincache_size = 0;
7157
7158         // set up r_skinframe loading system for textures
7159         memset(&r_skinframe, 0, sizeof(r_skinframe));
7160         r_skinframe.loadsequence = 1;
7161         Mem_ExpandableArray_NewArray(&r_skinframe.array, r_main_mempool, sizeof(skinframe_t), 256);
7162
7163         r_main_texturepool = R_AllocTexturePool();
7164         R_BuildBlankTextures();
7165         R_BuildNoTexture();
7166         if (vid.support.arb_texture_cube_map)
7167         {
7168                 R_BuildWhiteCube();
7169                 R_BuildNormalizationCube();
7170         }
7171         r_texture_fogattenuation = NULL;
7172         r_texture_fogheighttexture = NULL;
7173         r_texture_gammaramps = NULL;
7174         //r_texture_fogintensity = NULL;
7175         memset(&r_bloomstate, 0, sizeof(r_bloomstate));
7176         memset(&r_waterstate, 0, sizeof(r_waterstate));
7177         r_glsl_permutation = NULL;
7178         memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash));
7179         Mem_ExpandableArray_NewArray(&r_glsl_permutationarray, r_main_mempool, sizeof(r_glsl_permutation_t), 256);
7180         glslshaderstring = NULL;
7181 #ifdef SUPPORTCG
7182         r_cg_permutation = NULL;
7183         memset(r_cg_permutationhash, 0, sizeof(r_cg_permutationhash));
7184         Mem_ExpandableArray_NewArray(&r_cg_permutationarray, r_main_mempool, sizeof(r_cg_permutation_t), 256);
7185         cgshaderstring = NULL;
7186 #endif
7187 #ifdef SUPPORTD3D
7188         r_hlsl_permutation = NULL;
7189         memset(r_hlsl_permutationhash, 0, sizeof(r_hlsl_permutationhash));
7190         Mem_ExpandableArray_NewArray(&r_hlsl_permutationarray, r_main_mempool, sizeof(r_hlsl_permutation_t), 256);
7191         hlslshaderstring = NULL;
7192 #endif
7193         memset(&r_svbsp, 0, sizeof (r_svbsp));
7194
7195         r_refdef.fogmasktable_density = 0;
7196 }
7197
7198 void gl_main_shutdown(void)
7199 {
7200         R_AnimCache_Free();
7201         R_FrameData_Reset();
7202
7203         R_Main_FreeViewCache();
7204
7205         switch(vid.renderpath)
7206         {
7207         case RENDERPATH_GL11:
7208         case RENDERPATH_GL13:
7209         case RENDERPATH_GL20:
7210         case RENDERPATH_CGGL:
7211                 if (r_maxqueries)
7212                         qglDeleteQueriesARB(r_maxqueries, r_queries);
7213                 break;
7214         case RENDERPATH_D3D9:
7215                 //Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
7216                 break;
7217         case RENDERPATH_D3D10:
7218                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
7219                 break;
7220         case RENDERPATH_D3D11:
7221                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
7222                 break;
7223         }
7224
7225         r_numqueries = 0;
7226         r_maxqueries = 0;
7227         memset(r_queries, 0, sizeof(r_queries));
7228
7229         r_qwskincache = NULL;
7230         r_qwskincache_size = 0;
7231
7232         // clear out the r_skinframe state
7233         Mem_ExpandableArray_FreeArray(&r_skinframe.array);
7234         memset(&r_skinframe, 0, sizeof(r_skinframe));
7235
7236         if (r_svbsp.nodes)
7237                 Mem_Free(r_svbsp.nodes);
7238         memset(&r_svbsp, 0, sizeof (r_svbsp));
7239         R_FreeTexturePool(&r_main_texturepool);
7240         loadingscreentexture = NULL;
7241         r_texture_blanknormalmap = NULL;
7242         r_texture_white = NULL;
7243         r_texture_grey128 = NULL;
7244         r_texture_black = NULL;
7245         r_texture_whitecube = NULL;
7246         r_texture_normalizationcube = NULL;
7247         r_texture_fogattenuation = NULL;
7248         r_texture_fogheighttexture = NULL;
7249         r_texture_gammaramps = NULL;
7250         r_texture_numcubemaps = 0;
7251         //r_texture_fogintensity = NULL;
7252         memset(&r_bloomstate, 0, sizeof(r_bloomstate));
7253         memset(&r_waterstate, 0, sizeof(r_waterstate));
7254         R_GLSL_Restart_f();
7255 }
7256
7257 extern void CL_ParseEntityLump(char *entitystring);
7258 void gl_main_newmap(void)
7259 {
7260         // FIXME: move this code to client
7261         char *entities, entname[MAX_QPATH];
7262         if (r_qwskincache)
7263                 Mem_Free(r_qwskincache);
7264         r_qwskincache = NULL;
7265         r_qwskincache_size = 0;
7266         if (cl.worldmodel)
7267         {
7268                 dpsnprintf(entname, sizeof(entname), "%s.ent", cl.worldnamenoextension);
7269                 if ((entities = (char *)FS_LoadFile(entname, tempmempool, true, NULL)))
7270                 {
7271                         CL_ParseEntityLump(entities);
7272                         Mem_Free(entities);
7273                         return;
7274                 }
7275                 if (cl.worldmodel->brush.entities)
7276                         CL_ParseEntityLump(cl.worldmodel->brush.entities);
7277         }
7278         R_Main_FreeViewCache();
7279
7280         R_FrameData_Reset();
7281 }
7282
7283 void GL_Main_Init(void)
7284 {
7285         r_main_mempool = Mem_AllocPool("Renderer", 0, NULL);
7286
7287         Cmd_AddCommand("r_glsl_restart", R_GLSL_Restart_f, "unloads GLSL shaders, they will then be reloaded as needed");
7288         Cmd_AddCommand("r_glsl_dumpshader", R_GLSL_DumpShader_f, "dumps the engine internal default.glsl shader into glsl/default.glsl");
7289         // FIXME: the client should set up r_refdef.fog stuff including the fogmasktable
7290         if (gamemode == GAME_NEHAHRA)
7291         {
7292                 Cvar_RegisterVariable (&gl_fogenable);
7293                 Cvar_RegisterVariable (&gl_fogdensity);
7294                 Cvar_RegisterVariable (&gl_fogred);
7295                 Cvar_RegisterVariable (&gl_foggreen);
7296                 Cvar_RegisterVariable (&gl_fogblue);
7297                 Cvar_RegisterVariable (&gl_fogstart);
7298                 Cvar_RegisterVariable (&gl_fogend);
7299                 Cvar_RegisterVariable (&gl_skyclip);
7300         }
7301         Cvar_RegisterVariable(&r_motionblur);
7302         Cvar_RegisterVariable(&r_motionblur_maxblur);
7303         Cvar_RegisterVariable(&r_motionblur_bmin);
7304         Cvar_RegisterVariable(&r_motionblur_vmin);
7305         Cvar_RegisterVariable(&r_motionblur_vmax);
7306         Cvar_RegisterVariable(&r_motionblur_vcoeff);
7307         Cvar_RegisterVariable(&r_motionblur_randomize);
7308         Cvar_RegisterVariable(&r_damageblur);
7309         Cvar_RegisterVariable(&r_equalize_entities_fullbright);
7310         Cvar_RegisterVariable(&r_equalize_entities_minambient);
7311         Cvar_RegisterVariable(&r_equalize_entities_by);
7312         Cvar_RegisterVariable(&r_equalize_entities_to);
7313         Cvar_RegisterVariable(&r_depthfirst);
7314         Cvar_RegisterVariable(&r_useinfinitefarclip);
7315         Cvar_RegisterVariable(&r_farclip_base);
7316         Cvar_RegisterVariable(&r_farclip_world);
7317         Cvar_RegisterVariable(&r_nearclip);
7318         Cvar_RegisterVariable(&r_showbboxes);
7319         Cvar_RegisterVariable(&r_showsurfaces);
7320         Cvar_RegisterVariable(&r_showtris);
7321         Cvar_RegisterVariable(&r_shownormals);
7322         Cvar_RegisterVariable(&r_showlighting);
7323         Cvar_RegisterVariable(&r_showshadowvolumes);
7324         Cvar_RegisterVariable(&r_showcollisionbrushes);
7325         Cvar_RegisterVariable(&r_showcollisionbrushes_polygonfactor);
7326         Cvar_RegisterVariable(&r_showcollisionbrushes_polygonoffset);
7327         Cvar_RegisterVariable(&r_showdisabledepthtest);
7328         Cvar_RegisterVariable(&r_drawportals);
7329         Cvar_RegisterVariable(&r_drawentities);
7330         Cvar_RegisterVariable(&r_draw2d);
7331         Cvar_RegisterVariable(&r_drawworld);
7332         Cvar_RegisterVariable(&r_cullentities_trace);
7333         Cvar_RegisterVariable(&r_cullentities_trace_samples);
7334         Cvar_RegisterVariable(&r_cullentities_trace_tempentitysamples);
7335         Cvar_RegisterVariable(&r_cullentities_trace_enlarge);
7336         Cvar_RegisterVariable(&r_cullentities_trace_delay);
7337         Cvar_RegisterVariable(&r_drawviewmodel);
7338         Cvar_RegisterVariable(&r_drawexteriormodel);
7339         Cvar_RegisterVariable(&r_speeds);
7340         Cvar_RegisterVariable(&r_fullbrights);
7341         Cvar_RegisterVariable(&r_wateralpha);
7342         Cvar_RegisterVariable(&r_dynamic);
7343         Cvar_RegisterVariable(&r_fakelight);
7344         Cvar_RegisterVariable(&r_fakelight_intensity);
7345         Cvar_RegisterVariable(&r_fullbright);
7346         Cvar_RegisterVariable(&r_shadows);
7347         Cvar_RegisterVariable(&r_shadows_darken);
7348         Cvar_RegisterVariable(&r_shadows_drawafterrtlighting);
7349         Cvar_RegisterVariable(&r_shadows_castfrombmodels);
7350         Cvar_RegisterVariable(&r_shadows_throwdistance);
7351         Cvar_RegisterVariable(&r_shadows_throwdirection);
7352         Cvar_RegisterVariable(&r_shadows_focus);
7353         Cvar_RegisterVariable(&r_shadows_shadowmapscale);
7354         Cvar_RegisterVariable(&r_q1bsp_skymasking);
7355         Cvar_RegisterVariable(&r_polygonoffset_submodel_factor);
7356         Cvar_RegisterVariable(&r_polygonoffset_submodel_offset);
7357         Cvar_RegisterVariable(&r_polygonoffset_decals_factor);
7358         Cvar_RegisterVariable(&r_polygonoffset_decals_offset);
7359         Cvar_RegisterVariable(&r_fog_exp2);
7360         Cvar_RegisterVariable(&r_drawfog);
7361         Cvar_RegisterVariable(&r_transparentdepthmasking);
7362         Cvar_RegisterVariable(&r_texture_dds_load);
7363         Cvar_RegisterVariable(&r_texture_dds_save);
7364         Cvar_RegisterVariable(&r_texture_convertsRGB_2d);
7365         Cvar_RegisterVariable(&r_texture_convertsRGB_skin);
7366         Cvar_RegisterVariable(&r_texture_convertsRGB_cubemap);
7367         Cvar_RegisterVariable(&r_texture_convertsRGB_skybox);
7368         Cvar_RegisterVariable(&r_texture_convertsRGB_particles);
7369         Cvar_RegisterVariable(&r_textureunits);
7370         Cvar_RegisterVariable(&gl_combine);
7371         Cvar_RegisterVariable(&r_glsl);
7372         Cvar_RegisterVariable(&r_glsl_deluxemapping);
7373         Cvar_RegisterVariable(&r_glsl_offsetmapping);
7374         Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping);
7375         Cvar_RegisterVariable(&r_glsl_offsetmapping_scale);
7376         Cvar_RegisterVariable(&r_glsl_postprocess);
7377         Cvar_RegisterVariable(&r_glsl_postprocess_uservec1);
7378         Cvar_RegisterVariable(&r_glsl_postprocess_uservec2);
7379         Cvar_RegisterVariable(&r_glsl_postprocess_uservec3);
7380         Cvar_RegisterVariable(&r_glsl_postprocess_uservec4);
7381         Cvar_RegisterVariable(&r_water);
7382         Cvar_RegisterVariable(&r_water_resolutionmultiplier);
7383         Cvar_RegisterVariable(&r_water_clippingplanebias);
7384         Cvar_RegisterVariable(&r_water_refractdistort);
7385         Cvar_RegisterVariable(&r_water_reflectdistort);
7386         Cvar_RegisterVariable(&r_water_scissormode);
7387         Cvar_RegisterVariable(&r_lerpsprites);
7388         Cvar_RegisterVariable(&r_lerpmodels);
7389         Cvar_RegisterVariable(&r_lerplightstyles);
7390         Cvar_RegisterVariable(&r_waterscroll);
7391         Cvar_RegisterVariable(&r_bloom);
7392         Cvar_RegisterVariable(&r_bloom_colorscale);
7393         Cvar_RegisterVariable(&r_bloom_brighten);
7394         Cvar_RegisterVariable(&r_bloom_blur);
7395         Cvar_RegisterVariable(&r_bloom_resolution);
7396         Cvar_RegisterVariable(&r_bloom_colorexponent);
7397         Cvar_RegisterVariable(&r_bloom_colorsubtract);
7398         Cvar_RegisterVariable(&r_hdr);
7399         Cvar_RegisterVariable(&r_hdr_scenebrightness);
7400         Cvar_RegisterVariable(&r_hdr_glowintensity);
7401         Cvar_RegisterVariable(&r_hdr_range);
7402         Cvar_RegisterVariable(&r_smoothnormals_areaweighting);
7403         Cvar_RegisterVariable(&developer_texturelogging);
7404         Cvar_RegisterVariable(&gl_lightmaps);
7405         Cvar_RegisterVariable(&r_test);
7406         Cvar_RegisterVariable(&r_glsl_saturation);
7407         Cvar_RegisterVariable(&r_glsl_saturation_redcompensate);
7408         Cvar_RegisterVariable(&r_framedatasize);
7409         if (gamemode == GAME_NEHAHRA || gamemode == GAME_TENEBRAE)
7410                 Cvar_SetValue("r_fullbrights", 0);
7411         R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap, NULL, NULL);
7412
7413         Cvar_RegisterVariable(&r_track_sprites);
7414         Cvar_RegisterVariable(&r_track_sprites_flags);
7415         Cvar_RegisterVariable(&r_track_sprites_scalew);
7416         Cvar_RegisterVariable(&r_track_sprites_scaleh);
7417         Cvar_RegisterVariable(&r_overheadsprites_perspective);
7418         Cvar_RegisterVariable(&r_overheadsprites_pushback);
7419 }
7420
7421 extern void R_Textures_Init(void);
7422 extern void GL_Draw_Init(void);
7423 extern void GL_Main_Init(void);
7424 extern void R_Shadow_Init(void);
7425 extern void R_Sky_Init(void);
7426 extern void GL_Surf_Init(void);
7427 extern void R_Particles_Init(void);
7428 extern void R_Explosion_Init(void);
7429 extern void gl_backend_init(void);
7430 extern void Sbar_Init(void);
7431 extern void R_LightningBeams_Init(void);
7432 extern void Mod_RenderInit(void);
7433 extern void Font_Init(void);
7434
7435 void Render_Init(void)
7436 {
7437         gl_backend_init();
7438         R_Textures_Init();
7439         GL_Main_Init();
7440         Font_Init();
7441         GL_Draw_Init();
7442         R_Shadow_Init();
7443         R_Sky_Init();
7444         GL_Surf_Init();
7445         Sbar_Init();
7446         R_Particles_Init();
7447         R_Explosion_Init();
7448         R_LightningBeams_Init();
7449         Mod_RenderInit();
7450 }
7451
7452 /*
7453 ===============
7454 GL_Init
7455 ===============
7456 */
7457 extern char *ENGINE_EXTENSIONS;
7458 void GL_Init (void)
7459 {
7460         gl_renderer = (const char *)qglGetString(GL_RENDERER);
7461         gl_vendor = (const char *)qglGetString(GL_VENDOR);
7462         gl_version = (const char *)qglGetString(GL_VERSION);
7463         gl_extensions = (const char *)qglGetString(GL_EXTENSIONS);
7464
7465         if (!gl_extensions)
7466                 gl_extensions = "";
7467         if (!gl_platformextensions)
7468                 gl_platformextensions = "";
7469
7470         Con_Printf("GL_VENDOR: %s\n", gl_vendor);
7471         Con_Printf("GL_RENDERER: %s\n", gl_renderer);
7472         Con_Printf("GL_VERSION: %s\n", gl_version);
7473         Con_DPrintf("GL_EXTENSIONS: %s\n", gl_extensions);
7474         Con_DPrintf("%s_EXTENSIONS: %s\n", gl_platform, gl_platformextensions);
7475
7476         VID_CheckExtensions();
7477
7478         // LordHavoc: report supported extensions
7479         Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
7480
7481         // clear to black (loading plaque will be seen over this)
7482         GL_Clear(GL_COLOR_BUFFER_BIT, NULL, 1.0f, 128);
7483 }
7484
7485 int R_CullBox(const vec3_t mins, const vec3_t maxs)
7486 {
7487         int i;
7488         mplane_t *p;
7489         for (i = 0;i < r_refdef.view.numfrustumplanes;i++)
7490         {
7491                 // skip nearclip plane, it often culls portals when you are very close, and is almost never useful
7492                 if (i == 4)
7493                         continue;
7494                 p = r_refdef.view.frustum + i;
7495                 switch(p->signbits)
7496                 {
7497                 default:
7498                 case 0:
7499                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
7500                                 return true;
7501                         break;
7502                 case 1:
7503                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
7504                                 return true;
7505                         break;
7506                 case 2:
7507                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
7508                                 return true;
7509                         break;
7510                 case 3:
7511                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
7512                                 return true;
7513                         break;
7514                 case 4:
7515                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
7516                                 return true;
7517                         break;
7518                 case 5:
7519                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
7520                                 return true;
7521                         break;
7522                 case 6:
7523                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
7524                                 return true;
7525                         break;
7526                 case 7:
7527                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
7528                                 return true;
7529                         break;
7530                 }
7531         }
7532         return false;
7533 }
7534
7535 int R_CullBoxCustomPlanes(const vec3_t mins, const vec3_t maxs, int numplanes, const mplane_t *planes)
7536 {
7537         int i;
7538         const mplane_t *p;
7539         for (i = 0;i < numplanes;i++)
7540         {
7541                 p = planes + i;
7542                 switch(p->signbits)
7543                 {
7544                 default:
7545                 case 0:
7546                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
7547                                 return true;
7548                         break;
7549                 case 1:
7550                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
7551                                 return true;
7552                         break;
7553                 case 2:
7554                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
7555                                 return true;
7556                         break;
7557                 case 3:
7558                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
7559                                 return true;
7560                         break;
7561                 case 4:
7562                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
7563                                 return true;
7564                         break;
7565                 case 5:
7566                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
7567                                 return true;
7568                         break;
7569                 case 6:
7570                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
7571                                 return true;
7572                         break;
7573                 case 7:
7574                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
7575                                 return true;
7576                         break;
7577                 }
7578         }
7579         return false;
7580 }
7581
7582 //==================================================================================
7583
7584 // LordHavoc: this stores temporary data used within the same frame
7585
7586 qboolean r_framedata_failed;
7587 static size_t r_framedata_size;
7588 static size_t r_framedata_current;
7589 static void *r_framedata_base;
7590
7591 void R_FrameData_Reset(void)
7592 {
7593         if (r_framedata_base)
7594                 Mem_Free(r_framedata_base);
7595         r_framedata_base = NULL;
7596         r_framedata_size = 0;
7597         r_framedata_current = 0;
7598         r_framedata_failed = false;
7599 }
7600
7601 void R_FrameData_NewFrame(void)
7602 {
7603         size_t wantedsize;
7604         if (r_framedata_failed)
7605                 Cvar_SetValueQuick(&r_framedatasize, r_framedatasize.value + 1.0f);
7606         wantedsize = (size_t)(r_framedatasize.value * 1024*1024);
7607         wantedsize = bound(65536, wantedsize, 128*1024*1024);
7608         if (r_framedata_size != wantedsize)
7609         {
7610                 r_framedata_size = wantedsize;
7611                 if (r_framedata_base)
7612                         Mem_Free(r_framedata_base);
7613                 r_framedata_base = Mem_Alloc(r_main_mempool, r_framedata_size);
7614         }
7615         r_framedata_current = 0;
7616         r_framedata_failed = false;
7617 }
7618
7619 void *R_FrameData_Alloc(size_t size)
7620 {
7621         void *data;
7622
7623         // align to 16 byte boundary
7624         size = (size + 15) & ~15;
7625         data = (void *)((unsigned char*)r_framedata_base + r_framedata_current);
7626         r_framedata_current += size;
7627
7628         // check overflow
7629         if (r_framedata_current > r_framedata_size)
7630                 r_framedata_failed = true;
7631
7632         // return NULL on everything after a failure
7633         if (r_framedata_failed)
7634                 return NULL;
7635
7636         return data;
7637 }
7638
7639 void *R_FrameData_Store(size_t size, void *data)
7640 {
7641         void *d = R_FrameData_Alloc(size);
7642         if (d)
7643                 memcpy(d, data, size);
7644         return d;
7645 }
7646
7647 //==================================================================================
7648
7649 // LordHavoc: animcache originally written by Echon, rewritten since then
7650
7651 /**
7652  * Animation cache prevents re-generating mesh data for an animated model
7653  * multiple times in one frame for lighting, shadowing, reflections, etc.
7654  */
7655
7656 void R_AnimCache_Free(void)
7657 {
7658 }
7659
7660 void R_AnimCache_ClearCache(void)
7661 {
7662         int i;
7663         entity_render_t *ent;
7664
7665         for (i = 0;i < r_refdef.scene.numentities;i++)
7666         {
7667                 ent = r_refdef.scene.entities[i];
7668                 ent->animcache_vertex3f = NULL;
7669                 ent->animcache_normal3f = NULL;
7670                 ent->animcache_svector3f = NULL;
7671                 ent->animcache_tvector3f = NULL;
7672                 ent->animcache_vertexposition = NULL;
7673                 ent->animcache_vertexmesh = NULL;
7674                 ent->animcache_vertexpositionbuffer = NULL;
7675                 ent->animcache_vertexmeshbuffer = NULL;
7676         }
7677 }
7678
7679 void R_AnimCache_UpdateEntityMeshBuffers(entity_render_t *ent, int numvertices)
7680 {
7681         int i;
7682
7683         // identical memory layout, so no need to allocate...
7684         // this also provides the vertexposition structure to everything, e.g.
7685         // depth masked rendering currently uses it even if having separate
7686         // arrays
7687         // NOTE: get rid of this optimization if changing it to e.g. 4f
7688         ent->animcache_vertexposition = (r_vertexposition_t *)ent->animcache_vertex3f;
7689
7690         // TODO:
7691         // get rid of following uses of VERTEXPOSITION, change to the array:
7692         // R_DrawTextureSurfaceList_Sky if skyrendermasked
7693         // R_DrawSurface_TransparentCallback if r_transparentdepthmasking.integer
7694         // R_DrawTextureSurfaceList_DepthOnly
7695         // R_Q1BSP_DrawShadowMap
7696
7697         switch(vid.renderpath)
7698         {
7699         case RENDERPATH_GL20:
7700         case RENDERPATH_CGGL:
7701                 // need the meshbuffers if !gl_mesh_separatearrays.integer
7702                 if (gl_mesh_separatearrays.integer)
7703                         return;
7704                 break;
7705         case RENDERPATH_D3D9:
7706         case RENDERPATH_D3D10:
7707         case RENDERPATH_D3D11:
7708                 // always need the meshbuffers
7709                 break;
7710         case RENDERPATH_GL13:
7711         case RENDERPATH_GL11:
7712                 // never need the meshbuffers
7713                 return;
7714         }
7715
7716         if (!ent->animcache_vertexmesh && ent->animcache_normal3f)
7717                 ent->animcache_vertexmesh = (r_vertexmesh_t *)R_FrameData_Alloc(sizeof(r_vertexmesh_t)*numvertices);
7718         /*
7719         if (!ent->animcache_vertexposition)
7720                 ent->animcache_vertexposition = (r_vertexposition_t *)R_FrameData_Alloc(sizeof(r_vertexposition_t)*numvertices);
7721         */
7722         if (ent->animcache_vertexposition)
7723         {
7724                 /*
7725                 for (i = 0;i < numvertices;i++)
7726                         memcpy(ent->animcache_vertexposition[i].vertex3f, ent->animcache_vertex3f + 3*i, sizeof(float[3]));
7727                 */
7728                 // TODO: upload vertex buffer?
7729         }
7730         if (ent->animcache_vertexmesh)
7731         {
7732                 memcpy(ent->animcache_vertexmesh, ent->model->surfmesh.vertexmesh, sizeof(r_vertexmesh_t)*numvertices);
7733                 for (i = 0;i < numvertices;i++)
7734                         memcpy(ent->animcache_vertexmesh[i].vertex3f, ent->animcache_vertex3f + 3*i, sizeof(float[3]));
7735                 if (ent->animcache_svector3f)
7736                         for (i = 0;i < numvertices;i++)
7737                                 memcpy(ent->animcache_vertexmesh[i].svector3f, ent->animcache_svector3f + 3*i, sizeof(float[3]));
7738                 if (ent->animcache_tvector3f)
7739                         for (i = 0;i < numvertices;i++)
7740                                 memcpy(ent->animcache_vertexmesh[i].tvector3f, ent->animcache_tvector3f + 3*i, sizeof(float[3]));
7741                 if (ent->animcache_normal3f)
7742                         for (i = 0;i < numvertices;i++)
7743                                 memcpy(ent->animcache_vertexmesh[i].normal3f, ent->animcache_normal3f + 3*i, sizeof(float[3]));
7744                 // TODO: upload vertex buffer?
7745         }
7746 }
7747
7748 qboolean R_AnimCache_GetEntity(entity_render_t *ent, qboolean wantnormals, qboolean wanttangents)
7749 {
7750         dp_model_t *model = ent->model;
7751         int numvertices;
7752         // see if it's already cached this frame
7753         if (ent->animcache_vertex3f)
7754         {
7755                 // add normals/tangents if needed (this only happens with multiple views, reflections, cameras, etc)
7756                 if (wantnormals || wanttangents)
7757                 {
7758                         if (ent->animcache_normal3f)
7759                                 wantnormals = false;
7760                         if (ent->animcache_svector3f)
7761                                 wanttangents = false;
7762                         if (wantnormals || wanttangents)
7763                         {
7764                                 numvertices = model->surfmesh.num_vertices;
7765                                 if (wantnormals)
7766                                         ent->animcache_normal3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
7767                                 if (wanttangents)
7768                                 {
7769                                         ent->animcache_svector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
7770                                         ent->animcache_tvector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
7771                                 }
7772                                 if (!r_framedata_failed)
7773                                 {
7774                                         model->AnimateVertices(model, ent->frameblend, ent->skeleton, NULL, wantnormals ? ent->animcache_normal3f : NULL, wanttangents ? ent->animcache_svector3f : NULL, wanttangents ? ent->animcache_tvector3f : NULL);
7775                                         R_AnimCache_UpdateEntityMeshBuffers(ent, model->surfmesh.num_vertices);
7776                                 }
7777                         }
7778                 }
7779         }
7780         else
7781         {
7782                 // see if this ent is worth caching
7783                 if (!model || !model->Draw || !model->surfmesh.isanimated || !model->AnimateVertices || (ent->frameblend[0].lerp == 1 && ent->frameblend[0].subframe == 0 && !ent->skeleton))
7784                         return false;
7785                 // get some memory for this entity and generate mesh data
7786                 numvertices = model->surfmesh.num_vertices;
7787                 ent->animcache_vertex3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
7788                 if (wantnormals)
7789                         ent->animcache_normal3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
7790                 if (wanttangents)
7791                 {
7792                         ent->animcache_svector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
7793                         ent->animcache_tvector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
7794                 }
7795                 if (!r_framedata_failed)
7796                 {
7797                         model->AnimateVertices(model, ent->frameblend, ent->skeleton, ent->animcache_vertex3f, ent->animcache_normal3f, ent->animcache_svector3f, ent->animcache_tvector3f);
7798                         R_AnimCache_UpdateEntityMeshBuffers(ent, model->surfmesh.num_vertices);
7799                 }
7800         }
7801         return !r_framedata_failed;
7802 }
7803
7804 void R_AnimCache_CacheVisibleEntities(void)
7805 {
7806         int i;
7807         qboolean wantnormals = true;
7808         qboolean wanttangents = !r_showsurfaces.integer;
7809
7810         switch(vid.renderpath)
7811         {
7812         case RENDERPATH_GL20:
7813         case RENDERPATH_CGGL:
7814         case RENDERPATH_D3D9:
7815         case RENDERPATH_D3D10:
7816         case RENDERPATH_D3D11:
7817                 break;
7818         case RENDERPATH_GL13:
7819         case RENDERPATH_GL11:
7820                 wanttangents = false;
7821                 break;
7822         }
7823
7824         if (r_shownormals.integer)
7825                 wanttangents = wantnormals = true;
7826
7827         // TODO: thread this
7828         // NOTE: R_PrepareRTLights() also caches entities
7829
7830         for (i = 0;i < r_refdef.scene.numentities;i++)
7831                 if (r_refdef.viewcache.entityvisible[i])
7832                         R_AnimCache_GetEntity(r_refdef.scene.entities[i], wantnormals, wanttangents);
7833 }
7834
7835 //==================================================================================
7836
7837 static void R_View_UpdateEntityLighting (void)
7838 {
7839         int i;
7840         entity_render_t *ent;
7841         vec3_t tempdiffusenormal, avg;
7842         vec_t f, fa, fd, fdd;
7843         qboolean skipunseen = r_shadows.integer != 1; //|| R_Shadow_ShadowMappingEnabled();
7844
7845         for (i = 0;i < r_refdef.scene.numentities;i++)
7846         {
7847                 ent = r_refdef.scene.entities[i];
7848
7849                 // skip unseen models
7850                 if (!r_refdef.viewcache.entityvisible[i] && skipunseen)
7851                         continue;
7852
7853                 // skip bsp models
7854                 if (ent->model && ent->model->brush.num_leafs)
7855                 {
7856                         // TODO: use modellight for r_ambient settings on world?
7857                         VectorSet(ent->modellight_ambient, 0, 0, 0);
7858                         VectorSet(ent->modellight_diffuse, 0, 0, 0);
7859                         VectorSet(ent->modellight_lightdir, 0, 0, 1);
7860                         continue;
7861                 }
7862
7863                 // fetch the lighting from the worldmodel data
7864                 VectorClear(ent->modellight_ambient);
7865                 VectorClear(ent->modellight_diffuse);
7866                 VectorClear(tempdiffusenormal);
7867                 if ((ent->flags & RENDER_LIGHT) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.LightPoint)
7868                 {
7869                         vec3_t org;
7870                         Matrix4x4_OriginFromMatrix(&ent->matrix, org);
7871
7872                         // complete lightning for lit sprites
7873                         // todo: make a EF_ field so small ents could be lit purely by modellight and skipping real rtlight pass (like EF_NORTLIGHT)?
7874                         if (ent->model->type == mod_sprite && !(ent->model->data_textures[0].basematerialflags & MATERIALFLAG_FULLBRIGHT))
7875                         {
7876                                 if (ent->model->sprite.sprnum_type == SPR_OVERHEAD) // apply offset for overhead sprites
7877                                         org[2] = org[2] + r_overheadsprites_pushback.value;
7878                                 R_CompleteLightPoint(ent->modellight_ambient, ent->modellight_diffuse, ent->modellight_lightdir, org, true, true);
7879                         }
7880                         else
7881                                 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, org, ent->modellight_ambient, ent->modellight_diffuse, tempdiffusenormal);
7882
7883                         if(ent->flags & RENDER_EQUALIZE)
7884                         {
7885                                 // first fix up ambient lighting...
7886                                 if(r_equalize_entities_minambient.value > 0)
7887                                 {
7888                                         fd = 0.299f * ent->modellight_diffuse[0] + 0.587f * ent->modellight_diffuse[1] + 0.114f * ent->modellight_diffuse[2];
7889                                         if(fd > 0)
7890                                         {
7891                                                 fa = (0.299f * ent->modellight_ambient[0] + 0.587f * ent->modellight_ambient[1] + 0.114f * ent->modellight_ambient[2]);
7892                                                 if(fa < r_equalize_entities_minambient.value * fd)
7893                                                 {
7894                                                         // solve:
7895                                                         //   fa'/fd' = minambient
7896                                                         //   fa'+0.25*fd' = fa+0.25*fd
7897                                                         //   ...
7898                                                         //   fa' = fd' * minambient
7899                                                         //   fd'*(0.25+minambient) = fa+0.25*fd
7900                                                         //   ...
7901                                                         //   fd' = (fa+0.25*fd) * 1 / (0.25+minambient)
7902                                                         //   fa' = (fa+0.25*fd) * minambient / (0.25+minambient)
7903                                                         //   ...
7904                                                         fdd = (fa + 0.25f * fd) / (0.25f + r_equalize_entities_minambient.value);
7905                                                         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
7906                                                         VectorMA(ent->modellight_ambient, (1-f)*0.25f, ent->modellight_diffuse, ent->modellight_ambient);
7907                                                         VectorScale(ent->modellight_diffuse, f, ent->modellight_diffuse);
7908                                                 }
7909                                         }
7910                                 }
7911
7912                                 if(r_equalize_entities_to.value > 0 && r_equalize_entities_by.value != 0)
7913                                 {
7914                                         VectorMA(ent->modellight_ambient, 0.25f, ent->modellight_diffuse, avg);
7915                                         f = 0.299f * avg[0] + 0.587f * avg[1] + 0.114f * avg[2];
7916                                         if(f > 0)
7917                                         {
7918                                                 f = pow(f / r_equalize_entities_to.value, -r_equalize_entities_by.value);
7919                                                 VectorScale(ent->modellight_ambient, f, ent->modellight_ambient);
7920                                                 VectorScale(ent->modellight_diffuse, f, ent->modellight_diffuse);
7921                                         }
7922                                 }
7923                         }
7924                 }
7925                 else // highly rare
7926                         VectorSet(ent->modellight_ambient, 1, 1, 1);
7927
7928                 // move the light direction into modelspace coordinates for lighting code
7929                 Matrix4x4_Transform3x3(&ent->inversematrix, tempdiffusenormal, ent->modellight_lightdir);
7930                 if(VectorLength2(ent->modellight_lightdir) == 0)
7931                         VectorSet(ent->modellight_lightdir, 0, 0, 1); // have to set SOME valid vector here
7932                 VectorNormalize(ent->modellight_lightdir);
7933         }
7934 }
7935
7936 #define MAX_LINEOFSIGHTTRACES 64
7937
7938 static qboolean R_CanSeeBox(int numsamples, vec_t enlarge, vec3_t eye, vec3_t entboxmins, vec3_t entboxmaxs)
7939 {
7940         int i;
7941         vec3_t boxmins, boxmaxs;
7942         vec3_t start;
7943         vec3_t end;
7944         dp_model_t *model = r_refdef.scene.worldmodel;
7945
7946         if (!model || !model->brush.TraceLineOfSight)
7947                 return true;
7948
7949         // expand the box a little
7950         boxmins[0] = (enlarge+1) * entboxmins[0] - enlarge * entboxmaxs[0];
7951         boxmaxs[0] = (enlarge+1) * entboxmaxs[0] - enlarge * entboxmins[0];
7952         boxmins[1] = (enlarge+1) * entboxmins[1] - enlarge * entboxmaxs[1];
7953         boxmaxs[1] = (enlarge+1) * entboxmaxs[1] - enlarge * entboxmins[1];
7954         boxmins[2] = (enlarge+1) * entboxmins[2] - enlarge * entboxmaxs[2];
7955         boxmaxs[2] = (enlarge+1) * entboxmaxs[2] - enlarge * entboxmins[2];
7956
7957         // return true if eye is inside enlarged box
7958         if (BoxesOverlap(boxmins, boxmaxs, eye, eye))
7959                 return true;
7960
7961         // try center
7962         VectorCopy(eye, start);
7963         VectorMAM(0.5f, boxmins, 0.5f, boxmaxs, end);
7964         if (model->brush.TraceLineOfSight(model, start, end))
7965                 return true;
7966
7967         // try various random positions
7968         for (i = 0;i < numsamples;i++)
7969         {
7970                 VectorSet(end, lhrandom(boxmins[0], boxmaxs[0]), lhrandom(boxmins[1], boxmaxs[1]), lhrandom(boxmins[2], boxmaxs[2]));
7971                 if (model->brush.TraceLineOfSight(model, start, end))
7972                         return true;
7973         }
7974
7975         return false;
7976 }
7977
7978
7979 static void R_View_UpdateEntityVisible (void)
7980 {
7981         int i;
7982         int renderimask;
7983         int samples;
7984         entity_render_t *ent;
7985
7986         renderimask = r_refdef.envmap                                    ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL)
7987                 : r_waterstate.renderingrefraction                       ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL)
7988                 : (chase_active.integer || r_waterstate.renderingscene)  ? RENDER_VIEWMODEL
7989                 :                                                          RENDER_EXTERIORMODEL;
7990         if (!r_drawviewmodel.integer)
7991                 renderimask |= RENDER_VIEWMODEL;
7992         if (!r_drawexteriormodel.integer)
7993                 renderimask |= RENDER_EXTERIORMODEL;
7994         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs)
7995         {
7996                 // worldmodel can check visibility
7997                 memset(r_refdef.viewcache.entityvisible, 0, r_refdef.scene.numentities);
7998                 for (i = 0;i < r_refdef.scene.numentities;i++)
7999                 {
8000                         ent = r_refdef.scene.entities[i];
8001                         if (!(ent->flags & renderimask))
8002                         if (!R_CullBox(ent->mins, ent->maxs) || (ent->model && ent->model->type == mod_sprite && (ent->model->sprite.sprnum_type == SPR_LABEL || ent->model->sprite.sprnum_type == SPR_LABEL_SCALE)))
8003                         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))
8004                                 r_refdef.viewcache.entityvisible[i] = true;
8005                 }
8006                 if(r_cullentities_trace.integer && r_refdef.scene.worldmodel->brush.TraceLineOfSight && !r_refdef.view.useclipplane)
8007                         // sorry, this check doesn't work for portal/reflection/refraction renders as the view origin is not useful for culling
8008                 {
8009                         for (i = 0;i < r_refdef.scene.numentities;i++)
8010                         {
8011                                 ent = r_refdef.scene.entities[i];
8012                                 if(r_refdef.viewcache.entityvisible[i] && !(ent->flags & (RENDER_VIEWMODEL | RENDER_NOCULL | RENDER_NODEPTHTEST)) && !(ent->model && (ent->model->name[0] == '*')))
8013                                 {
8014                                         samples = ent->entitynumber ? r_cullentities_trace_samples.integer : r_cullentities_trace_tempentitysamples.integer;
8015                                         if (samples < 0)
8016                                                 continue; // temp entities do pvs only
8017                                         if(R_CanSeeBox(samples, r_cullentities_trace_enlarge.value, r_refdef.view.origin, ent->mins, ent->maxs))
8018                                                 ent->last_trace_visibility = realtime;
8019                                         if(ent->last_trace_visibility < realtime - r_cullentities_trace_delay.value)
8020                                                 r_refdef.viewcache.entityvisible[i] = 0;
8021                                 }
8022                         }
8023                 }
8024         }
8025         else
8026         {
8027                 // no worldmodel or it can't check visibility
8028                 for (i = 0;i < r_refdef.scene.numentities;i++)
8029                 {
8030                         ent = r_refdef.scene.entities[i];
8031                         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));
8032                 }
8033         }
8034 }
8035
8036 /// only used if skyrendermasked, and normally returns false
8037 int R_DrawBrushModelsSky (void)
8038 {
8039         int i, sky;
8040         entity_render_t *ent;
8041
8042         sky = false;
8043         for (i = 0;i < r_refdef.scene.numentities;i++)
8044         {
8045                 if (!r_refdef.viewcache.entityvisible[i])
8046                         continue;
8047                 ent = r_refdef.scene.entities[i];
8048                 if (!ent->model || !ent->model->DrawSky)
8049                         continue;
8050                 ent->model->DrawSky(ent);
8051                 sky = true;
8052         }
8053         return sky;
8054 }
8055
8056 static void R_DrawNoModel(entity_render_t *ent);
8057 static void R_DrawModels(void)
8058 {
8059         int i;
8060         entity_render_t *ent;
8061
8062         for (i = 0;i < r_refdef.scene.numentities;i++)
8063         {
8064                 if (!r_refdef.viewcache.entityvisible[i])
8065                         continue;
8066                 ent = r_refdef.scene.entities[i];
8067                 r_refdef.stats.entities++;
8068                 if (ent->model && ent->model->Draw != NULL)
8069                         ent->model->Draw(ent);
8070                 else
8071                         R_DrawNoModel(ent);
8072         }
8073 }
8074
8075 static void R_DrawModelsDepth(void)
8076 {
8077         int i;
8078         entity_render_t *ent;
8079
8080         for (i = 0;i < r_refdef.scene.numentities;i++)
8081         {
8082                 if (!r_refdef.viewcache.entityvisible[i])
8083                         continue;
8084                 ent = r_refdef.scene.entities[i];
8085                 if (ent->model && ent->model->DrawDepth != NULL)
8086                         ent->model->DrawDepth(ent);
8087         }
8088 }
8089
8090 static void R_DrawModelsDebug(void)
8091 {
8092         int i;
8093         entity_render_t *ent;
8094
8095         for (i = 0;i < r_refdef.scene.numentities;i++)
8096         {
8097                 if (!r_refdef.viewcache.entityvisible[i])
8098                         continue;
8099                 ent = r_refdef.scene.entities[i];
8100                 if (ent->model && ent->model->DrawDebug != NULL)
8101                         ent->model->DrawDebug(ent);
8102         }
8103 }
8104
8105 static void R_DrawModelsAddWaterPlanes(void)
8106 {
8107         int i;
8108         entity_render_t *ent;
8109
8110         for (i = 0;i < r_refdef.scene.numentities;i++)
8111         {
8112                 if (!r_refdef.viewcache.entityvisible[i])
8113                         continue;
8114                 ent = r_refdef.scene.entities[i];
8115                 if (ent->model && ent->model->DrawAddWaterPlanes != NULL)
8116                         ent->model->DrawAddWaterPlanes(ent);
8117         }
8118 }
8119
8120 static void R_View_SetFrustum(const int *scissor)
8121 {
8122         int i;
8123         double fpx = +1, fnx = -1, fpy = +1, fny = -1;
8124         vec3_t forward, left, up, origin, v;
8125
8126         if(scissor)
8127         {
8128                 // flipped x coordinates (because x points left here)
8129                 fpx =  1.0 - 2.0 * (scissor[0]              - r_refdef.view.viewport.x) / (double) (r_refdef.view.viewport.width);
8130                 fnx =  1.0 - 2.0 * (scissor[0] + scissor[2] - r_refdef.view.viewport.x) / (double) (r_refdef.view.viewport.width);
8131
8132                 // D3D Y coordinate is top to bottom, OpenGL is bottom to top, fix the D3D one
8133                 switch(vid.renderpath)
8134                 {
8135                         case RENDERPATH_D3D9:
8136                         case RENDERPATH_D3D10:
8137                         case RENDERPATH_D3D11:
8138                                 // non-flipped y coordinates
8139                                 fny = -1.0 + 2.0 * (vid.height - scissor[1] - scissor[3] - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
8140                                 fpy = -1.0 + 2.0 * (vid.height - scissor[1]              - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
8141                                 break;
8142                         case RENDERPATH_GL11:
8143                         case RENDERPATH_GL13:
8144                         case RENDERPATH_GL20:
8145                         case RENDERPATH_CGGL:
8146                                 // non-flipped y coordinates
8147                                 fny = -1.0 + 2.0 * (scissor[1]              - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
8148                                 fpy = -1.0 + 2.0 * (scissor[1] + scissor[3] - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
8149                                 break;
8150                 }
8151         }
8152
8153         // we can't trust r_refdef.view.forward and friends in reflected scenes
8154         Matrix4x4_ToVectors(&r_refdef.view.matrix, forward, left, up, origin);
8155
8156 #if 0
8157         r_refdef.view.frustum[0].normal[0] = 0 - 1.0 / r_refdef.view.frustum_x;
8158         r_refdef.view.frustum[0].normal[1] = 0 - 0;
8159         r_refdef.view.frustum[0].normal[2] = -1 - 0;
8160         r_refdef.view.frustum[1].normal[0] = 0 + 1.0 / r_refdef.view.frustum_x;
8161         r_refdef.view.frustum[1].normal[1] = 0 + 0;
8162         r_refdef.view.frustum[1].normal[2] = -1 + 0;
8163         r_refdef.view.frustum[2].normal[0] = 0 - 0;
8164         r_refdef.view.frustum[2].normal[1] = 0 - 1.0 / r_refdef.view.frustum_y;
8165         r_refdef.view.frustum[2].normal[2] = -1 - 0;
8166         r_refdef.view.frustum[3].normal[0] = 0 + 0;
8167         r_refdef.view.frustum[3].normal[1] = 0 + 1.0 / r_refdef.view.frustum_y;
8168         r_refdef.view.frustum[3].normal[2] = -1 + 0;
8169 #endif
8170
8171 #if 0
8172         zNear = r_refdef.nearclip;
8173         nudge = 1.0 - 1.0 / (1<<23);
8174         r_refdef.view.frustum[4].normal[0] = 0 - 0;
8175         r_refdef.view.frustum[4].normal[1] = 0 - 0;
8176         r_refdef.view.frustum[4].normal[2] = -1 - -nudge;
8177         r_refdef.view.frustum[4].dist = 0 - -2 * zNear * nudge;
8178         r_refdef.view.frustum[5].normal[0] = 0 + 0;
8179         r_refdef.view.frustum[5].normal[1] = 0 + 0;
8180         r_refdef.view.frustum[5].normal[2] = -1 + -nudge;
8181         r_refdef.view.frustum[5].dist = 0 + -2 * zNear * nudge;
8182 #endif
8183
8184
8185
8186 #if 0
8187         r_refdef.view.frustum[0].normal[0] = m[3] - m[0];
8188         r_refdef.view.frustum[0].normal[1] = m[7] - m[4];
8189         r_refdef.view.frustum[0].normal[2] = m[11] - m[8];
8190         r_refdef.view.frustum[0].dist = m[15] - m[12];
8191
8192         r_refdef.view.frustum[1].normal[0] = m[3] + m[0];
8193         r_refdef.view.frustum[1].normal[1] = m[7] + m[4];
8194         r_refdef.view.frustum[1].normal[2] = m[11] + m[8];
8195         r_refdef.view.frustum[1].dist = m[15] + m[12];
8196
8197         r_refdef.view.frustum[2].normal[0] = m[3] - m[1];
8198         r_refdef.view.frustum[2].normal[1] = m[7] - m[5];
8199         r_refdef.view.frustum[2].normal[2] = m[11] - m[9];
8200         r_refdef.view.frustum[2].dist = m[15] - m[13];
8201
8202         r_refdef.view.frustum[3].normal[0] = m[3] + m[1];
8203         r_refdef.view.frustum[3].normal[1] = m[7] + m[5];
8204         r_refdef.view.frustum[3].normal[2] = m[11] + m[9];
8205         r_refdef.view.frustum[3].dist = m[15] + m[13];
8206
8207         r_refdef.view.frustum[4].normal[0] = m[3] - m[2];
8208         r_refdef.view.frustum[4].normal[1] = m[7] - m[6];
8209         r_refdef.view.frustum[4].normal[2] = m[11] - m[10];
8210         r_refdef.view.frustum[4].dist = m[15] - m[14];
8211
8212         r_refdef.view.frustum[5].normal[0] = m[3] + m[2];
8213         r_refdef.view.frustum[5].normal[1] = m[7] + m[6];
8214         r_refdef.view.frustum[5].normal[2] = m[11] + m[10];
8215         r_refdef.view.frustum[5].dist = m[15] + m[14];
8216 #endif
8217
8218         if (r_refdef.view.useperspective)
8219         {
8220                 // calculate frustum corners, which are used to calculate deformed frustum planes for shadow caster culling
8221                 VectorMAMAM(1024, forward, fnx * 1024.0 * r_refdef.view.frustum_x, left, fny * 1024.0 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[0]);
8222                 VectorMAMAM(1024, forward, fpx * 1024.0 * r_refdef.view.frustum_x, left, fny * 1024.0 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[1]);
8223                 VectorMAMAM(1024, forward, fnx * 1024.0 * r_refdef.view.frustum_x, left, fpy * 1024.0 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[2]);
8224                 VectorMAMAM(1024, forward, fpx * 1024.0 * r_refdef.view.frustum_x, left, fpy * 1024.0 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[3]);
8225
8226                 // then the normals from the corners relative to origin
8227                 CrossProduct(r_refdef.view.frustumcorner[2], r_refdef.view.frustumcorner[0], r_refdef.view.frustum[0].normal);
8228                 CrossProduct(r_refdef.view.frustumcorner[1], r_refdef.view.frustumcorner[3], r_refdef.view.frustum[1].normal);
8229                 CrossProduct(r_refdef.view.frustumcorner[0], r_refdef.view.frustumcorner[1], r_refdef.view.frustum[2].normal);
8230                 CrossProduct(r_refdef.view.frustumcorner[3], r_refdef.view.frustumcorner[2], r_refdef.view.frustum[3].normal);
8231
8232                 // in a NORMAL view, forward cross left == up
8233                 // in a REFLECTED view, forward cross left == down
8234                 // so our cross products above need to be adjusted for a left handed coordinate system
8235                 CrossProduct(forward, left, v);
8236                 if(DotProduct(v, up) < 0)
8237                 {
8238                         VectorNegate(r_refdef.view.frustum[0].normal, r_refdef.view.frustum[0].normal);
8239                         VectorNegate(r_refdef.view.frustum[1].normal, r_refdef.view.frustum[1].normal);
8240                         VectorNegate(r_refdef.view.frustum[2].normal, r_refdef.view.frustum[2].normal);
8241                         VectorNegate(r_refdef.view.frustum[3].normal, r_refdef.view.frustum[3].normal);
8242                 }
8243
8244                 // Leaving those out was a mistake, those were in the old code, and they
8245                 // fix a reproducable bug in this one: frustum culling got fucked up when viewmatrix was an identity matrix
8246                 // I couldn't reproduce it after adding those normalizations. --blub
8247                 VectorNormalize(r_refdef.view.frustum[0].normal);
8248                 VectorNormalize(r_refdef.view.frustum[1].normal);
8249                 VectorNormalize(r_refdef.view.frustum[2].normal);
8250                 VectorNormalize(r_refdef.view.frustum[3].normal);
8251
8252                 // make the corners absolute
8253                 VectorAdd(r_refdef.view.frustumcorner[0], r_refdef.view.origin, r_refdef.view.frustumcorner[0]);
8254                 VectorAdd(r_refdef.view.frustumcorner[1], r_refdef.view.origin, r_refdef.view.frustumcorner[1]);
8255                 VectorAdd(r_refdef.view.frustumcorner[2], r_refdef.view.origin, r_refdef.view.frustumcorner[2]);
8256                 VectorAdd(r_refdef.view.frustumcorner[3], r_refdef.view.origin, r_refdef.view.frustumcorner[3]);
8257
8258                 // one more normal
8259                 VectorCopy(forward, r_refdef.view.frustum[4].normal);
8260
8261                 r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[0].normal);
8262                 r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[1].normal);
8263                 r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[2].normal);
8264                 r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[3].normal);
8265                 r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[4].normal) + r_refdef.nearclip;
8266         }
8267         else
8268         {
8269                 VectorScale(left, -r_refdef.view.ortho_x, r_refdef.view.frustum[0].normal);
8270                 VectorScale(left,  r_refdef.view.ortho_x, r_refdef.view.frustum[1].normal);
8271                 VectorScale(up, -r_refdef.view.ortho_y, r_refdef.view.frustum[2].normal);
8272                 VectorScale(up,  r_refdef.view.ortho_y, r_refdef.view.frustum[3].normal);
8273                 VectorCopy(forward, r_refdef.view.frustum[4].normal);
8274                 r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[0].normal) + r_refdef.view.ortho_x;
8275                 r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[1].normal) + r_refdef.view.ortho_x;
8276                 r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[2].normal) + r_refdef.view.ortho_y;
8277                 r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[3].normal) + r_refdef.view.ortho_y;
8278                 r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[4].normal) + r_refdef.nearclip;
8279         }
8280         r_refdef.view.numfrustumplanes = 5;
8281
8282         if (r_refdef.view.useclipplane)
8283         {
8284                 r_refdef.view.numfrustumplanes = 6;
8285                 r_refdef.view.frustum[5] = r_refdef.view.clipplane;
8286         }
8287
8288         for (i = 0;i < r_refdef.view.numfrustumplanes;i++)
8289                 PlaneClassify(r_refdef.view.frustum + i);
8290
8291         // LordHavoc: note to all quake engine coders, Quake had a special case
8292         // for 90 degrees which assumed a square view (wrong), so I removed it,
8293         // Quake2 has it disabled as well.
8294
8295         // rotate R_VIEWFORWARD right by FOV_X/2 degrees
8296         //RotatePointAroundVector( r_refdef.view.frustum[0].normal, up, forward, -(90 - r_refdef.fov_x / 2));
8297         //r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, frustum[0].normal);
8298         //PlaneClassify(&frustum[0]);
8299
8300         // rotate R_VIEWFORWARD left by FOV_X/2 degrees
8301         //RotatePointAroundVector( r_refdef.view.frustum[1].normal, up, forward, (90 - r_refdef.fov_x / 2));
8302         //r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, frustum[1].normal);
8303         //PlaneClassify(&frustum[1]);
8304
8305         // rotate R_VIEWFORWARD up by FOV_X/2 degrees
8306         //RotatePointAroundVector( r_refdef.view.frustum[2].normal, left, forward, -(90 - r_refdef.fov_y / 2));
8307         //r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, frustum[2].normal);
8308         //PlaneClassify(&frustum[2]);
8309
8310         // rotate R_VIEWFORWARD down by FOV_X/2 degrees
8311         //RotatePointAroundVector( r_refdef.view.frustum[3].normal, left, forward, (90 - r_refdef.fov_y / 2));
8312         //r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, frustum[3].normal);
8313         //PlaneClassify(&frustum[3]);
8314
8315         // nearclip plane
8316         //VectorCopy(forward, r_refdef.view.frustum[4].normal);
8317         //r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, frustum[4].normal) + r_nearclip.value;
8318         //PlaneClassify(&frustum[4]);
8319 }
8320
8321 void R_View_UpdateWithScissor(const int *myscissor)
8322 {
8323         R_Main_ResizeViewCache();
8324         R_View_SetFrustum(myscissor);
8325         R_View_WorldVisibility(r_refdef.view.useclipplane);
8326         R_View_UpdateEntityVisible();
8327         R_View_UpdateEntityLighting();
8328 }
8329
8330 void R_View_Update(void)
8331 {
8332         R_Main_ResizeViewCache();
8333         R_View_SetFrustum(NULL);
8334         R_View_WorldVisibility(r_refdef.view.useclipplane);
8335         R_View_UpdateEntityVisible();
8336         R_View_UpdateEntityLighting();
8337 }
8338
8339 void R_SetupView(qboolean allowwaterclippingplane)
8340 {
8341         const float *customclipplane = NULL;
8342         float plane[4];
8343         if (r_refdef.view.useclipplane && allowwaterclippingplane)
8344         {
8345                 // LordHavoc: couldn't figure out how to make this approach the
8346                 vec_t dist = r_refdef.view.clipplane.dist - r_water_clippingplanebias.value;
8347                 vec_t viewdist = DotProduct(r_refdef.view.origin, r_refdef.view.clipplane.normal);
8348                 if (viewdist < r_refdef.view.clipplane.dist + r_water_clippingplanebias.value)
8349                         dist = r_refdef.view.clipplane.dist;
8350                 plane[0] = r_refdef.view.clipplane.normal[0];
8351                 plane[1] = r_refdef.view.clipplane.normal[1];
8352                 plane[2] = r_refdef.view.clipplane.normal[2];
8353                 plane[3] = dist;
8354                 customclipplane = plane;
8355         }
8356
8357         if (!r_refdef.view.useperspective)
8358                 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);
8359         else if (vid.stencil && r_useinfinitefarclip.integer)
8360                 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);
8361         else
8362                 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);
8363         R_SetViewport(&r_refdef.view.viewport);
8364 }
8365
8366 void R_EntityMatrix(const matrix4x4_t *matrix)
8367 {
8368         if (gl_modelmatrixchanged || memcmp(matrix, &gl_modelmatrix, sizeof(matrix4x4_t)))
8369         {
8370                 gl_modelmatrixchanged = false;
8371                 gl_modelmatrix = *matrix;
8372                 Matrix4x4_Concat(&gl_modelviewmatrix, &gl_viewmatrix, &gl_modelmatrix);
8373                 Matrix4x4_Concat(&gl_modelviewprojectionmatrix, &gl_projectionmatrix, &gl_modelviewmatrix);
8374                 Matrix4x4_ToArrayFloatGL(&gl_modelviewmatrix, gl_modelview16f);
8375                 Matrix4x4_ToArrayFloatGL(&gl_modelviewprojectionmatrix, gl_modelviewprojection16f);
8376                 CHECKGLERROR
8377                 switch(vid.renderpath)
8378                 {
8379                 case RENDERPATH_D3D9:
8380 #ifdef SUPPORTD3D
8381                         hlslVSSetParameter16f(D3DVSREGISTER_ModelViewProjectionMatrix, gl_modelviewprojection16f);
8382                         hlslVSSetParameter16f(D3DVSREGISTER_ModelViewMatrix, gl_modelview16f);
8383 #endif
8384                         break;
8385                 case RENDERPATH_D3D10:
8386                         Con_DPrintf("FIXME D3D10 shader %s:%i\n", __FILE__, __LINE__);
8387                         break;
8388                 case RENDERPATH_D3D11:
8389                         Con_DPrintf("FIXME D3D11 shader %s:%i\n", __FILE__, __LINE__);
8390                         break;
8391                 case RENDERPATH_GL20:
8392                         if (r_glsl_permutation && r_glsl_permutation->loc_ModelViewProjectionMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewProjectionMatrix, 1, false, gl_modelviewprojection16f);
8393                         if (r_glsl_permutation && r_glsl_permutation->loc_ModelViewMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewMatrix, 1, false, gl_modelview16f);
8394                         qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
8395                         break;
8396                 case RENDERPATH_CGGL:
8397 #ifdef SUPPORTCG
8398                         CHECKCGERROR
8399                         if (r_cg_permutation && r_cg_permutation->vp_ModelViewProjectionMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewProjectionMatrix, gl_modelviewprojection16f);CHECKCGERROR
8400                         if (r_cg_permutation && r_cg_permutation->vp_ModelViewMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewMatrix, gl_modelview16f);CHECKCGERROR
8401                         qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
8402 #endif
8403                         break;
8404                 case RENDERPATH_GL13:
8405                 case RENDERPATH_GL11:
8406                         qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
8407                         break;
8408                 }
8409         }
8410 }
8411
8412 void R_ResetViewRendering2D(void)
8413 {
8414         r_viewport_t viewport;
8415         DrawQ_Finish();
8416
8417         // GL is weird because it's bottom to top, r_refdef.view.y is top to bottom
8418         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);
8419         R_SetViewport(&viewport);
8420         GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
8421         GL_Color(1, 1, 1, 1);
8422         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
8423         GL_BlendFunc(GL_ONE, GL_ZERO);
8424         GL_AlphaTest(false);
8425         GL_ScissorTest(false);
8426         GL_DepthMask(false);
8427         GL_DepthRange(0, 1);
8428         GL_DepthTest(false);
8429         GL_DepthFunc(GL_LEQUAL);
8430         R_EntityMatrix(&identitymatrix);
8431         R_Mesh_ResetTextureState();
8432         GL_PolygonOffset(0, 0);
8433         R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255);
8434         switch(vid.renderpath)
8435         {
8436         case RENDERPATH_GL11:
8437         case RENDERPATH_GL13:
8438         case RENDERPATH_GL20:
8439         case RENDERPATH_CGGL:
8440                 qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
8441                 break;
8442         case RENDERPATH_D3D9:
8443         case RENDERPATH_D3D10:
8444         case RENDERPATH_D3D11:
8445                 break;
8446         }
8447         GL_CullFace(GL_NONE);
8448 }
8449
8450 void R_ResetViewRendering3D(void)
8451 {
8452         DrawQ_Finish();
8453
8454         R_SetupView(true);
8455         GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
8456         GL_Color(1, 1, 1, 1);
8457         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
8458         GL_BlendFunc(GL_ONE, GL_ZERO);
8459         GL_AlphaTest(false);
8460         GL_ScissorTest(true);
8461         GL_DepthMask(true);
8462         GL_DepthRange(0, 1);
8463         GL_DepthTest(true);
8464         GL_DepthFunc(GL_LEQUAL);
8465         R_EntityMatrix(&identitymatrix);
8466         R_Mesh_ResetTextureState();
8467         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
8468         R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255);
8469         switch(vid.renderpath)
8470         {
8471         case RENDERPATH_GL11:
8472         case RENDERPATH_GL13:
8473         case RENDERPATH_GL20:
8474         case RENDERPATH_CGGL:
8475                 qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
8476                 break;
8477         case RENDERPATH_D3D9:
8478         case RENDERPATH_D3D10:
8479         case RENDERPATH_D3D11:
8480                 break;
8481         }
8482         GL_CullFace(r_refdef.view.cullface_back);
8483 }
8484
8485 /*
8486 ================
8487 R_RenderView_UpdateViewVectors
8488 ================
8489 */
8490 static void R_RenderView_UpdateViewVectors(void)
8491 {
8492         // break apart the view matrix into vectors for various purposes
8493         // it is important that this occurs outside the RenderScene function because that can be called from reflection renders, where the vectors come out wrong
8494         // however the r_refdef.view.origin IS updated in RenderScene intentionally - otherwise the sky renders at the wrong origin, etc
8495         Matrix4x4_ToVectors(&r_refdef.view.matrix, r_refdef.view.forward, r_refdef.view.left, r_refdef.view.up, r_refdef.view.origin);
8496         VectorNegate(r_refdef.view.left, r_refdef.view.right);
8497         // make an inverted copy of the view matrix for tracking sprites
8498         Matrix4x4_Invert_Simple(&r_refdef.view.inverse_matrix, &r_refdef.view.matrix);
8499 }
8500
8501 void R_RenderScene(void);
8502 void R_RenderWaterPlanes(void);
8503
8504 static void R_Water_StartFrame(void)
8505 {
8506         int i;
8507         int waterwidth, waterheight, texturewidth, textureheight, camerawidth, cameraheight;
8508         r_waterstate_waterplane_t *p;
8509
8510         if (vid.width > (int)vid.maxtexturesize_2d || vid.height > (int)vid.maxtexturesize_2d)
8511                 return;
8512
8513         switch(vid.renderpath)
8514         {
8515         case RENDERPATH_GL20:
8516         case RENDERPATH_CGGL:
8517         case RENDERPATH_D3D9:
8518         case RENDERPATH_D3D10:
8519         case RENDERPATH_D3D11:
8520                 break;
8521         case RENDERPATH_GL13:
8522         case RENDERPATH_GL11:
8523                 return;
8524         }
8525
8526         // set waterwidth and waterheight to the water resolution that will be
8527         // used (often less than the screen resolution for faster rendering)
8528         waterwidth = (int)bound(1, vid.width * r_water_resolutionmultiplier.value, vid.width);
8529         waterheight = (int)bound(1, vid.height * r_water_resolutionmultiplier.value, vid.height);
8530
8531         // calculate desired texture sizes
8532         // can't use water if the card does not support the texture size
8533         if (!r_water.integer || r_showsurfaces.integer)
8534                 texturewidth = textureheight = waterwidth = waterheight = camerawidth = cameraheight = 0;
8535         else if (vid.support.arb_texture_non_power_of_two)
8536         {
8537                 texturewidth = waterwidth;
8538                 textureheight = waterheight;
8539                 camerawidth = waterwidth;
8540                 cameraheight = waterheight;
8541         }
8542         else
8543         {
8544                 for (texturewidth   = 1;texturewidth   < waterwidth ;texturewidth   *= 2);
8545                 for (textureheight  = 1;textureheight  < waterheight;textureheight  *= 2);
8546                 for (camerawidth    = 1;camerawidth   <= waterwidth; camerawidth    *= 2); camerawidth  /= 2;
8547                 for (cameraheight   = 1;cameraheight  <= waterheight;cameraheight   *= 2); cameraheight /= 2;
8548         }
8549
8550         // allocate textures as needed
8551         if (r_waterstate.texturewidth != texturewidth || r_waterstate.textureheight != textureheight || r_waterstate.camerawidth != camerawidth || r_waterstate.cameraheight != cameraheight)
8552         {
8553                 r_waterstate.maxwaterplanes = MAX_WATERPLANES;
8554                 for (i = 0, p = r_waterstate.waterplanes;i < r_waterstate.maxwaterplanes;i++, p++)
8555                 {
8556                         if (p->texture_refraction)
8557                                 R_FreeTexture(p->texture_refraction);
8558                         p->texture_refraction = NULL;
8559                         if (p->texture_reflection)
8560                                 R_FreeTexture(p->texture_reflection);
8561                         p->texture_reflection = NULL;
8562                         if (p->texture_camera)
8563                                 R_FreeTexture(p->texture_camera);
8564                         p->texture_camera = NULL;
8565                 }
8566                 memset(&r_waterstate, 0, sizeof(r_waterstate));
8567                 r_waterstate.texturewidth = texturewidth;
8568                 r_waterstate.textureheight = textureheight;
8569                 r_waterstate.camerawidth = camerawidth;
8570                 r_waterstate.cameraheight = cameraheight;
8571         }
8572
8573         if (r_waterstate.texturewidth)
8574         {
8575                 r_waterstate.enabled = true;
8576
8577                 // when doing a reduced render (HDR) we want to use a smaller area
8578                 r_waterstate.waterwidth = (int)bound(1, r_refdef.view.width * r_water_resolutionmultiplier.value, r_refdef.view.width);
8579                 r_waterstate.waterheight = (int)bound(1, r_refdef.view.height * r_water_resolutionmultiplier.value, r_refdef.view.height);
8580
8581                 // set up variables that will be used in shader setup
8582                 r_waterstate.screenscale[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
8583                 r_waterstate.screenscale[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
8584                 r_waterstate.screencenter[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
8585                 r_waterstate.screencenter[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
8586         }
8587
8588         r_waterstate.maxwaterplanes = MAX_WATERPLANES;
8589         r_waterstate.numwaterplanes = 0;
8590 }
8591
8592 void R_Water_AddWaterPlane(msurface_t *surface, int entno)
8593 {
8594         int triangleindex, planeindex;
8595         const int *e;
8596         vec3_t vert[3];
8597         vec3_t normal;
8598         vec3_t center;
8599         mplane_t plane;
8600         r_waterstate_waterplane_t *p;
8601         texture_t *t = R_GetCurrentTexture(surface->texture);
8602
8603         // just use the first triangle with a valid normal for any decisions
8604         VectorClear(normal);
8605         for (triangleindex = 0, e = rsurface.modelelement3i + surface->num_firsttriangle * 3;triangleindex < surface->num_triangles;triangleindex++, e += 3)
8606         {
8607                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[0]*3, vert[0]);
8608                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[1]*3, vert[1]);
8609                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[2]*3, vert[2]);
8610                 TriangleNormal(vert[0], vert[1], vert[2], normal);
8611                 if (VectorLength2(normal) >= 0.001)
8612                         break;
8613         }
8614
8615         VectorCopy(normal, plane.normal);
8616         VectorNormalize(plane.normal);
8617         plane.dist = DotProduct(vert[0], plane.normal);
8618         PlaneClassify(&plane);
8619         if (PlaneDiff(r_refdef.view.origin, &plane) < 0)
8620         {
8621                 // skip backfaces (except if nocullface is set)
8622                 if (!(t->currentmaterialflags & MATERIALFLAG_NOCULLFACE))
8623                         return;
8624                 VectorNegate(plane.normal, plane.normal);
8625                 plane.dist *= -1;
8626                 PlaneClassify(&plane);
8627         }
8628
8629
8630         // find a matching plane if there is one
8631         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
8632                 if(p->camera_entity == t->camera_entity)
8633                         if (fabs(PlaneDiff(vert[0], &p->plane)) < 1 && fabs(PlaneDiff(vert[1], &p->plane)) < 1 && fabs(PlaneDiff(vert[2], &p->plane)) < 1)
8634                                 break;
8635         if (planeindex >= r_waterstate.maxwaterplanes)
8636                 return; // nothing we can do, out of planes
8637
8638         // if this triangle does not fit any known plane rendered this frame, add one
8639         if (planeindex >= r_waterstate.numwaterplanes)
8640         {
8641                 // store the new plane
8642                 r_waterstate.numwaterplanes++;
8643                 p->plane = plane;
8644                 // clear materialflags and pvs
8645                 p->materialflags = 0;
8646                 p->pvsvalid = false;
8647                 p->camera_entity = t->camera_entity;
8648                 VectorCopy(surface->mins, p->mins);
8649                 VectorCopy(surface->maxs, p->maxs);
8650         }
8651         else
8652         {
8653                 // merge mins/maxs
8654                 p->mins[0] = min(p->mins[0], surface->mins[0]);
8655                 p->mins[1] = min(p->mins[1], surface->mins[1]);
8656                 p->mins[2] = min(p->mins[2], surface->mins[2]);
8657                 p->maxs[0] = max(p->maxs[0], surface->maxs[0]);
8658                 p->maxs[1] = max(p->maxs[1], surface->maxs[1]);
8659                 p->maxs[2] = max(p->maxs[2], surface->maxs[2]);
8660         }
8661         // merge this surface's materialflags into the waterplane
8662         p->materialflags |= t->currentmaterialflags;
8663         if(!(p->materialflags & MATERIALFLAG_CAMERA))
8664         {
8665                 // merge this surface's PVS into the waterplane
8666                 VectorMAM(0.5f, surface->mins, 0.5f, surface->maxs, center);
8667                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS
8668                  && r_refdef.scene.worldmodel->brush.PointInLeaf && r_refdef.scene.worldmodel->brush.PointInLeaf(r_refdef.scene.worldmodel, center)->clusterindex >= 0)
8669                 {
8670                         r_refdef.scene.worldmodel->brush.FatPVS(r_refdef.scene.worldmodel, center, 2, p->pvsbits, sizeof(p->pvsbits), p->pvsvalid);
8671                         p->pvsvalid = true;
8672                 }
8673         }
8674 }
8675
8676 static void R_Water_ProcessPlanes(void)
8677 {
8678         int myscissor[4];
8679         r_refdef_view_t originalview;
8680         r_refdef_view_t myview;
8681         int planeindex;
8682         r_waterstate_waterplane_t *p;
8683         vec3_t visorigin;
8684
8685         originalview = r_refdef.view;
8686
8687         // make sure enough textures are allocated
8688         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
8689         {
8690                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
8691                 {
8692                         if (!p->texture_refraction)
8693                                 p->texture_refraction = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_refraction", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
8694                         if (!p->texture_refraction)
8695                                 goto error;
8696                 }
8697                 else if (p->materialflags & MATERIALFLAG_CAMERA)
8698                 {
8699                         if (!p->texture_camera)
8700                                 p->texture_camera = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_camera", planeindex), r_waterstate.camerawidth, r_waterstate.cameraheight, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_FORCELINEAR, -1, NULL);
8701                         if (!p->texture_camera)
8702                                 goto error;
8703                 }
8704
8705                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
8706                 {
8707                         if (!p->texture_reflection)
8708                                 p->texture_reflection = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_reflection", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
8709                         if (!p->texture_reflection)
8710                                 goto error;
8711                 }
8712         }
8713
8714         // render views
8715         r_refdef.view = originalview;
8716         r_refdef.view.showdebug = false;
8717         r_refdef.view.width = r_waterstate.waterwidth;
8718         r_refdef.view.height = r_waterstate.waterheight;
8719         r_refdef.view.useclipplane = true;
8720         myview = r_refdef.view;
8721         r_waterstate.renderingscene = true;
8722         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
8723         {
8724                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
8725                 {
8726                         r_refdef.view = myview;
8727                         if(r_water_scissormode.integer)
8728                         {
8729                                 R_SetupView(true);
8730                                 if(R_ScissorForBBox(p->mins, p->maxs, myscissor))
8731                                         continue; // FIXME the plane then still may get rendered but with broken texture, but it sure won't be visible
8732                         }
8733
8734                         // render reflected scene and copy into texture
8735                         Matrix4x4_Reflect(&r_refdef.view.matrix, p->plane.normal[0], p->plane.normal[1], p->plane.normal[2], p->plane.dist, -2);
8736                         // update the r_refdef.view.origin because otherwise the sky renders at the wrong location (amongst other problems)
8737                         Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, r_refdef.view.origin);
8738                         r_refdef.view.clipplane = p->plane;
8739
8740                         // reverse the cullface settings for this render
8741                         r_refdef.view.cullface_front = GL_FRONT;
8742                         r_refdef.view.cullface_back = GL_BACK;
8743                         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.num_pvsclusterbytes)
8744                         {
8745                                 r_refdef.view.usecustompvs = true;
8746                                 if (p->pvsvalid)
8747                                         memcpy(r_refdef.viewcache.world_pvsbits, p->pvsbits, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
8748                                 else
8749                                         memset(r_refdef.viewcache.world_pvsbits, 0xFF, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
8750                         }
8751
8752                         R_ResetViewRendering3D();
8753                         R_ClearScreen(r_refdef.fogenabled);
8754                         if(r_water_scissormode.integer & 2)
8755                                 R_View_UpdateWithScissor(myscissor);
8756                         else
8757                                 R_View_Update();
8758                         if(r_water_scissormode.integer & 1)
8759                                 GL_Scissor(myscissor[0], myscissor[1], myscissor[2], myscissor[3]);
8760                         R_RenderScene();
8761
8762                         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);
8763                 }
8764
8765                 // render the normal view scene and copy into texture
8766                 // (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)
8767                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
8768                 {
8769                         r_refdef.view = myview;
8770                         if(r_water_scissormode.integer)
8771                         {
8772                                 R_SetupView(true);
8773                                 if(R_ScissorForBBox(p->mins, p->maxs, myscissor))
8774                                         continue; // FIXME the plane then still may get rendered but with broken texture, but it sure won't be visible
8775                         }
8776
8777                         r_waterstate.renderingrefraction = true;
8778
8779                         r_refdef.view.clipplane = p->plane;
8780                         VectorNegate(r_refdef.view.clipplane.normal, r_refdef.view.clipplane.normal);
8781                         r_refdef.view.clipplane.dist = -r_refdef.view.clipplane.dist;
8782
8783                         if((p->materialflags & MATERIALFLAG_CAMERA) && p->camera_entity)
8784                         {
8785                                 // we need to perform a matrix transform to render the view... so let's get the transformation matrix
8786                                 r_waterstate.renderingrefraction = false; // we don't want to hide the player model from these ones
8787                                 CL_VM_TransformView(p->camera_entity - MAX_EDICTS, &r_refdef.view.matrix, &r_refdef.view.clipplane, visorigin);
8788                                 R_RenderView_UpdateViewVectors();
8789                                 if(r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS)
8790                                 {
8791                                         r_refdef.view.usecustompvs = true;
8792                                         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);
8793                                 }
8794                         }
8795
8796                         PlaneClassify(&r_refdef.view.clipplane);
8797
8798                         R_ResetViewRendering3D();
8799                         R_ClearScreen(r_refdef.fogenabled);
8800                         if(r_water_scissormode.integer & 2)
8801                                 R_View_UpdateWithScissor(myscissor);
8802                         else
8803                                 R_View_Update();
8804                         if(r_water_scissormode.integer & 1)
8805                                 GL_Scissor(myscissor[0], myscissor[1], myscissor[2], myscissor[3]);
8806                         R_RenderScene();
8807
8808                         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);
8809                         r_waterstate.renderingrefraction = false;
8810                 }
8811                 else if (p->materialflags & MATERIALFLAG_CAMERA)
8812                 {
8813                         r_refdef.view = myview;
8814
8815                         r_refdef.view.clipplane = p->plane;
8816                         VectorNegate(r_refdef.view.clipplane.normal, r_refdef.view.clipplane.normal);
8817                         r_refdef.view.clipplane.dist = -r_refdef.view.clipplane.dist;
8818
8819                         r_refdef.view.width = r_waterstate.camerawidth;
8820                         r_refdef.view.height = r_waterstate.cameraheight;
8821                         r_refdef.view.frustum_x = 1; // tan(45 * M_PI / 180.0);
8822                         r_refdef.view.frustum_y = 1; // tan(45 * M_PI / 180.0);
8823
8824                         if(p->camera_entity)
8825                         {
8826                                 // we need to perform a matrix transform to render the view... so let's get the transformation matrix
8827                                 CL_VM_TransformView(p->camera_entity - MAX_EDICTS, &r_refdef.view.matrix, &r_refdef.view.clipplane, visorigin);
8828                         }
8829
8830                         // note: all of the view is used for displaying... so
8831                         // there is no use in scissoring
8832
8833                         // reverse the cullface settings for this render
8834                         r_refdef.view.cullface_front = GL_FRONT;
8835                         r_refdef.view.cullface_back = GL_BACK;
8836                         // also reverse the view matrix
8837                         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
8838                         R_RenderView_UpdateViewVectors();
8839                         if(p->camera_entity && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS)
8840                         {
8841                                 r_refdef.view.usecustompvs = true;
8842                                 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);
8843                         }
8844
8845                         // camera needs no clipplane
8846                         r_refdef.view.useclipplane = false;
8847
8848                         PlaneClassify(&r_refdef.view.clipplane);
8849
8850                         R_ResetViewRendering3D();
8851                         R_ClearScreen(r_refdef.fogenabled);
8852                         R_View_Update();
8853                         R_RenderScene();
8854
8855                         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);
8856                         r_waterstate.renderingrefraction = false;
8857                 }
8858
8859         }
8860         r_waterstate.renderingscene = false;
8861         r_refdef.view = originalview;
8862         R_ResetViewRendering3D();
8863         R_ClearScreen(r_refdef.fogenabled);
8864         R_View_Update();
8865         return;
8866 error:
8867         r_refdef.view = originalview;
8868         r_waterstate.renderingscene = false;
8869         Cvar_SetValueQuick(&r_water, 0);
8870         Con_Printf("R_Water_ProcessPlanes: Error: texture creation failed!  Turned off r_water.\n");
8871         return;
8872 }
8873
8874 void R_Bloom_StartFrame(void)
8875 {
8876         int bloomtexturewidth, bloomtextureheight, screentexturewidth, screentextureheight;
8877
8878         switch(vid.renderpath)
8879         {
8880         case RENDERPATH_GL20:
8881         case RENDERPATH_CGGL:
8882         case RENDERPATH_D3D9:
8883         case RENDERPATH_D3D10:
8884         case RENDERPATH_D3D11:
8885                 break;
8886         case RENDERPATH_GL13:
8887         case RENDERPATH_GL11:
8888                 return;
8889         }
8890
8891         // set bloomwidth and bloomheight to the bloom resolution that will be
8892         // used (often less than the screen resolution for faster rendering)
8893         r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, vid.height);
8894         r_bloomstate.bloomheight = r_bloomstate.bloomwidth * vid.height / vid.width;
8895         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, vid.height);
8896         r_bloomstate.bloomwidth = bound(1, r_bloomstate.bloomwidth, (int)vid.maxtexturesize_2d);
8897         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, (int)vid.maxtexturesize_2d);
8898
8899         // calculate desired texture sizes
8900         if (vid.support.arb_texture_non_power_of_two)
8901         {
8902                 screentexturewidth = r_refdef.view.width;
8903                 screentextureheight = r_refdef.view.height;
8904                 bloomtexturewidth = r_bloomstate.bloomwidth;
8905                 bloomtextureheight = r_bloomstate.bloomheight;
8906         }
8907         else
8908         {
8909                 for (screentexturewidth  = 1;screentexturewidth  < vid.width               ;screentexturewidth  *= 2);
8910                 for (screentextureheight = 1;screentextureheight < vid.height              ;screentextureheight *= 2);
8911                 for (bloomtexturewidth   = 1;bloomtexturewidth   < r_bloomstate.bloomwidth ;bloomtexturewidth   *= 2);
8912                 for (bloomtextureheight  = 1;bloomtextureheight  < r_bloomstate.bloomheight;bloomtextureheight  *= 2);
8913         }
8914
8915         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))
8916         {
8917                 Cvar_SetValueQuick(&r_hdr, 0);
8918                 Cvar_SetValueQuick(&r_bloom, 0);
8919                 Cvar_SetValueQuick(&r_motionblur, 0);
8920                 Cvar_SetValueQuick(&r_damageblur, 0);
8921         }
8922
8923         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)))
8924                 screentexturewidth = screentextureheight = 0;
8925         if (!r_hdr.integer && !r_bloom.integer)
8926                 bloomtexturewidth = bloomtextureheight = 0;
8927
8928         // allocate textures as needed
8929         if (r_bloomstate.screentexturewidth != screentexturewidth || r_bloomstate.screentextureheight != screentextureheight)
8930         {
8931                 if (r_bloomstate.texture_screen)
8932                         R_FreeTexture(r_bloomstate.texture_screen);
8933                 r_bloomstate.texture_screen = NULL;
8934                 r_bloomstate.screentexturewidth = screentexturewidth;
8935                 r_bloomstate.screentextureheight = screentextureheight;
8936                 if (r_bloomstate.screentexturewidth && r_bloomstate.screentextureheight)
8937                         r_bloomstate.texture_screen = R_LoadTexture2D(r_main_texturepool, "screen", r_bloomstate.screentexturewidth, r_bloomstate.screentextureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_FORCENEAREST | TEXF_CLAMP, -1, NULL);
8938         }
8939         if (r_bloomstate.bloomtexturewidth != bloomtexturewidth || r_bloomstate.bloomtextureheight != bloomtextureheight)
8940         {
8941                 if (r_bloomstate.texture_bloom)
8942                         R_FreeTexture(r_bloomstate.texture_bloom);
8943                 r_bloomstate.texture_bloom = NULL;
8944                 r_bloomstate.bloomtexturewidth = bloomtexturewidth;
8945                 r_bloomstate.bloomtextureheight = bloomtextureheight;
8946                 if (r_bloomstate.bloomtexturewidth && r_bloomstate.bloomtextureheight)
8947                         r_bloomstate.texture_bloom = R_LoadTexture2D(r_main_texturepool, "bloom", r_bloomstate.bloomtexturewidth, r_bloomstate.bloomtextureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
8948         }
8949
8950         // when doing a reduced render (HDR) we want to use a smaller area
8951         r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, r_refdef.view.height);
8952         r_bloomstate.bloomheight = r_bloomstate.bloomwidth * r_refdef.view.height / r_refdef.view.width;
8953         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_refdef.view.height);
8954         r_bloomstate.bloomwidth = bound(1, r_bloomstate.bloomwidth, r_bloomstate.bloomtexturewidth);
8955         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_bloomstate.bloomtextureheight);
8956
8957         // set up a texcoord array for the full resolution screen image
8958         // (we have to keep this around to copy back during final render)
8959         r_bloomstate.screentexcoord2f[0] = 0;
8960         r_bloomstate.screentexcoord2f[1] = (float)r_refdef.view.height    / (float)r_bloomstate.screentextureheight;
8961         r_bloomstate.screentexcoord2f[2] = (float)r_refdef.view.width     / (float)r_bloomstate.screentexturewidth;
8962         r_bloomstate.screentexcoord2f[3] = (float)r_refdef.view.height    / (float)r_bloomstate.screentextureheight;
8963         r_bloomstate.screentexcoord2f[4] = (float)r_refdef.view.width     / (float)r_bloomstate.screentexturewidth;
8964         r_bloomstate.screentexcoord2f[5] = 0;
8965         r_bloomstate.screentexcoord2f[6] = 0;
8966         r_bloomstate.screentexcoord2f[7] = 0;
8967
8968         // set up a texcoord array for the reduced resolution bloom image
8969         // (which will be additive blended over the screen image)
8970         r_bloomstate.bloomtexcoord2f[0] = 0;
8971         r_bloomstate.bloomtexcoord2f[1] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
8972         r_bloomstate.bloomtexcoord2f[2] = (float)r_bloomstate.bloomwidth  / (float)r_bloomstate.bloomtexturewidth;
8973         r_bloomstate.bloomtexcoord2f[3] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
8974         r_bloomstate.bloomtexcoord2f[4] = (float)r_bloomstate.bloomwidth  / (float)r_bloomstate.bloomtexturewidth;
8975         r_bloomstate.bloomtexcoord2f[5] = 0;
8976         r_bloomstate.bloomtexcoord2f[6] = 0;
8977         r_bloomstate.bloomtexcoord2f[7] = 0;
8978
8979         switch(vid.renderpath)
8980         {
8981         case RENDERPATH_GL11:
8982         case RENDERPATH_GL13:
8983         case RENDERPATH_GL20:
8984         case RENDERPATH_CGGL:
8985                 break;
8986         case RENDERPATH_D3D9:
8987         case RENDERPATH_D3D10:
8988         case RENDERPATH_D3D11:
8989                 {
8990                         int i;
8991                         for (i = 0;i < 4;i++)
8992                         {
8993                                 r_bloomstate.screentexcoord2f[i*2+0] += 0.5f / (float)r_bloomstate.screentexturewidth;
8994                                 r_bloomstate.screentexcoord2f[i*2+1] += 0.5f / (float)r_bloomstate.screentextureheight;
8995                                 r_bloomstate.bloomtexcoord2f[i*2+0] += 0.5f / (float)r_bloomstate.bloomtexturewidth;
8996                                 r_bloomstate.bloomtexcoord2f[i*2+1] += 0.5f / (float)r_bloomstate.bloomtextureheight;
8997                         }
8998                 }
8999                 break;
9000         }
9001
9002         if (r_hdr.integer || r_bloom.integer)
9003         {
9004                 r_bloomstate.enabled = true;
9005                 r_bloomstate.hdr = r_hdr.integer != 0;
9006         }
9007
9008         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);
9009 }
9010
9011 void R_Bloom_CopyBloomTexture(float colorscale)
9012 {
9013         r_refdef.stats.bloom++;
9014
9015         // scale down screen texture to the bloom texture size
9016         CHECKGLERROR
9017         R_SetViewport(&r_bloomstate.viewport);
9018         GL_BlendFunc(GL_ONE, GL_ZERO);
9019         GL_Color(colorscale, colorscale, colorscale, 1);
9020         // D3D has upside down Y coords, the easiest way to flip this is to flip the screen vertices rather than the texcoords, so we just use a different array for that...
9021         switch(vid.renderpath)
9022         {
9023         case RENDERPATH_GL11:
9024         case RENDERPATH_GL13:
9025         case RENDERPATH_GL20:
9026         case RENDERPATH_CGGL:
9027                 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_bloomstate.screentexcoord2f);
9028                 break;
9029         case RENDERPATH_D3D9:
9030         case RENDERPATH_D3D10:
9031         case RENDERPATH_D3D11:
9032                 R_Mesh_PrepareVertices_Generic_Arrays(4, r_d3dscreenvertex3f, NULL, r_bloomstate.screentexcoord2f);
9033                 break;
9034         }
9035         // TODO: do boxfilter scale-down in shader?
9036         R_SetupShader_Generic(r_bloomstate.texture_screen, NULL, GL_MODULATE, 1);
9037         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
9038         r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
9039
9040         // we now have a bloom image in the framebuffer
9041         // copy it into the bloom image texture for later processing
9042         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);
9043         r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
9044 }
9045
9046 void R_Bloom_CopyHDRTexture(void)
9047 {
9048         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);
9049         r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
9050 }
9051
9052 void R_Bloom_MakeTexture(void)
9053 {
9054         int x, range, dir;
9055         float xoffset, yoffset, r, brighten;
9056
9057         r_refdef.stats.bloom++;
9058
9059         R_ResetViewRendering2D();
9060
9061         // we have a bloom image in the framebuffer
9062         CHECKGLERROR
9063         R_SetViewport(&r_bloomstate.viewport);
9064
9065         for (x = 1;x < min(r_bloom_colorexponent.value, 32);)
9066         {
9067                 x *= 2;
9068                 r = bound(0, r_bloom_colorexponent.value / x, 1);
9069                 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
9070                 GL_Color(r,r,r,1);
9071                 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_bloomstate.bloomtexcoord2f);
9072                 R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
9073                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
9074                 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
9075
9076                 // copy the vertically blurred bloom view to a texture
9077                 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);
9078                 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
9079         }
9080
9081         range = r_bloom_blur.integer * r_bloomstate.bloomwidth / 320;
9082         brighten = r_bloom_brighten.value;
9083         if (r_hdr.integer)
9084                 brighten *= r_hdr_range.value;
9085         brighten = sqrt(brighten);
9086         if(range >= 1)
9087                 brighten *= (3 * range) / (2 * range - 1); // compensate for the "dot particle"
9088         R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
9089
9090         for (dir = 0;dir < 2;dir++)
9091         {
9092                 // blend on at multiple vertical offsets to achieve a vertical blur
9093                 // TODO: do offset blends using GLSL
9094                 // TODO instead of changing the texcoords, change the target positions to prevent artifacts at edges
9095                 GL_BlendFunc(GL_ONE, GL_ZERO);
9096                 for (x = -range;x <= range;x++)
9097                 {
9098                         if (!dir){xoffset = 0;yoffset = x;}
9099                         else {xoffset = x;yoffset = 0;}
9100                         xoffset /= (float)r_bloomstate.bloomtexturewidth;
9101                         yoffset /= (float)r_bloomstate.bloomtextureheight;
9102                         // compute a texcoord array with the specified x and y offset
9103                         r_bloomstate.offsettexcoord2f[0] = xoffset+0;
9104                         r_bloomstate.offsettexcoord2f[1] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
9105                         r_bloomstate.offsettexcoord2f[2] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
9106                         r_bloomstate.offsettexcoord2f[3] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
9107                         r_bloomstate.offsettexcoord2f[4] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
9108                         r_bloomstate.offsettexcoord2f[5] = yoffset+0;
9109                         r_bloomstate.offsettexcoord2f[6] = xoffset+0;
9110                         r_bloomstate.offsettexcoord2f[7] = yoffset+0;
9111                         // this r value looks like a 'dot' particle, fading sharply to
9112                         // black at the edges
9113                         // (probably not realistic but looks good enough)
9114                         //r = ((range*range+1)/((float)(x*x+1)))/(range*2+1);
9115                         //r = brighten/(range*2+1);
9116                         r = brighten / (range * 2 + 1);
9117                         if(range >= 1)
9118                                 r *= (1 - x*x/(float)(range*range));
9119                         GL_Color(r, r, r, 1);
9120                         R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_bloomstate.offsettexcoord2f);
9121                         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
9122                         r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
9123                         GL_BlendFunc(GL_ONE, GL_ONE);
9124                 }
9125
9126                 // copy the vertically blurred bloom view to a texture
9127                 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);
9128                 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
9129         }
9130 }
9131
9132 void R_HDR_RenderBloomTexture(void)
9133 {
9134         int oldwidth, oldheight;
9135         float oldcolorscale;
9136
9137         oldcolorscale = r_refdef.view.colorscale;
9138         oldwidth = r_refdef.view.width;
9139         oldheight = r_refdef.view.height;
9140         r_refdef.view.width = r_bloomstate.bloomwidth;
9141         r_refdef.view.height = r_bloomstate.bloomheight;
9142
9143         // TODO: support GL_EXT_framebuffer_object rather than reusing the framebuffer?  it might improve SLI performance.
9144         // TODO: add exposure compensation features
9145         // TODO: add fp16 framebuffer support (using GL_EXT_framebuffer_object)
9146
9147         r_refdef.view.showdebug = false;
9148         r_refdef.view.colorscale *= r_bloom_colorscale.value / bound(1, r_hdr_range.value, 16);
9149
9150         R_ResetViewRendering3D();
9151
9152         R_ClearScreen(r_refdef.fogenabled);
9153         if (r_timereport_active)
9154                 R_TimeReport("HDRclear");
9155
9156         R_View_Update();
9157         if (r_timereport_active)
9158                 R_TimeReport("visibility");
9159
9160         // only do secondary renders with HDR if r_hdr is 2 or higher
9161         r_waterstate.numwaterplanes = 0;
9162         if (r_waterstate.enabled && r_hdr.integer >= 2)
9163                 R_RenderWaterPlanes();
9164
9165         r_refdef.view.showdebug = true;
9166         R_RenderScene();
9167         r_waterstate.numwaterplanes = 0;
9168
9169         R_ResetViewRendering2D();
9170
9171         R_Bloom_CopyHDRTexture();
9172         R_Bloom_MakeTexture();
9173
9174         // restore the view settings
9175         r_refdef.view.width = oldwidth;
9176         r_refdef.view.height = oldheight;
9177         r_refdef.view.colorscale = oldcolorscale;
9178
9179         R_ResetViewRendering3D();
9180
9181         R_ClearScreen(r_refdef.fogenabled);
9182         if (r_timereport_active)
9183                 R_TimeReport("viewclear");
9184 }
9185
9186 static void R_BlendView(void)
9187 {
9188         unsigned int permutation;
9189         float uservecs[4][4];
9190
9191         switch (vid.renderpath)
9192         {
9193         case RENDERPATH_GL20:
9194         case RENDERPATH_CGGL:
9195         case RENDERPATH_D3D9:
9196         case RENDERPATH_D3D10:
9197         case RENDERPATH_D3D11:
9198                 permutation =
9199                           (r_bloomstate.texture_bloom ? SHADERPERMUTATION_BLOOM : 0)
9200                         | (r_refdef.viewblend[3] > 0 ? SHADERPERMUTATION_VIEWTINT : 0)
9201                         | ((v_glslgamma.value && !vid_gammatables_trivial) ? SHADERPERMUTATION_GAMMARAMPS : 0)
9202                         | (r_glsl_postprocess.integer ? SHADERPERMUTATION_POSTPROCESSING : 0)
9203                         | ((!R_Stereo_ColorMasking() && r_glsl_saturation.value != 1) ? SHADERPERMUTATION_SATURATION : 0);
9204
9205                 if (r_bloomstate.texture_screen)
9206                 {
9207                         // make sure the buffer is available
9208                         if (r_bloom_blur.value < 1) { Cvar_SetValueQuick(&r_bloom_blur, 1); }
9209
9210                         R_ResetViewRendering2D();
9211
9212                         if(!R_Stereo_Active() && (r_motionblur.value > 0 || r_damageblur.value > 0))
9213                         {
9214                                 // declare variables
9215                                 float speed;
9216                                 static float avgspeed;
9217
9218                                 speed = VectorLength(cl.movement_velocity);
9219
9220                                 cl.motionbluralpha = bound(0, (cl.time - cl.oldtime) / max(0.001, r_motionblur_vcoeff.value), 1);
9221                                 avgspeed = avgspeed * (1 - cl.motionbluralpha) + speed * cl.motionbluralpha;
9222
9223                                 speed = (avgspeed - r_motionblur_vmin.value) / max(1, r_motionblur_vmax.value - r_motionblur_vmin.value);
9224                                 speed = bound(0, speed, 1);
9225                                 speed = speed * (1 - r_motionblur_bmin.value) + r_motionblur_bmin.value;
9226
9227                                 // calculate values into a standard alpha
9228                                 cl.motionbluralpha = 1 - exp(-
9229                                                 (
9230                                                  (r_motionblur.value * speed / 80)
9231                                                  +
9232                                                  (r_damageblur.value * (cl.cshifts[CSHIFT_DAMAGE].percent / 1600))
9233                                                 )
9234                                                 /
9235                                                 max(0.0001, cl.time - cl.oldtime) // fps independent
9236                                            );
9237
9238                                 cl.motionbluralpha *= lhrandom(1 - r_motionblur_randomize.value, 1 + r_motionblur_randomize.value);
9239                                 cl.motionbluralpha = bound(0, cl.motionbluralpha, r_motionblur_maxblur.value);
9240                                 // apply the blur
9241                                 if (cl.motionbluralpha > 0 && !r_refdef.envmap)
9242                                 {
9243                                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
9244                                         GL_Color(1, 1, 1, cl.motionbluralpha);
9245                                         switch(vid.renderpath)
9246                                         {
9247                                         case RENDERPATH_GL11:
9248                                         case RENDERPATH_GL13:
9249                                         case RENDERPATH_GL20:
9250                                         case RENDERPATH_CGGL:
9251                                                 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_bloomstate.screentexcoord2f);
9252                                                 break;
9253                                         case RENDERPATH_D3D9:
9254                                         case RENDERPATH_D3D10:
9255                                         case RENDERPATH_D3D11:
9256                                                 R_Mesh_PrepareVertices_Generic_Arrays(4, r_d3dscreenvertex3f, NULL, r_bloomstate.screentexcoord2f);
9257                                                 break;
9258                                         }
9259                                         R_SetupShader_Generic(r_bloomstate.texture_screen, NULL, GL_MODULATE, 1);
9260                                         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
9261                                         r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
9262                                 }
9263                         }
9264
9265                         // copy view into the screen texture
9266                         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);
9267                         r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
9268                 }
9269                 else if (!r_bloomstate.texture_bloom)
9270                 {
9271                         // we may still have to do view tint...
9272                         if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
9273                         {
9274                                 // apply a color tint to the whole view
9275                                 R_ResetViewRendering2D();
9276                                 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
9277                                 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, NULL);
9278                                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9279                                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
9280                                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
9281                         }
9282                         break; // no screen processing, no bloom, skip it
9283                 }
9284
9285                 if (r_bloomstate.texture_bloom && !r_bloomstate.hdr)
9286                 {
9287                         // render simple bloom effect
9288                         // copy the screen and shrink it and darken it for the bloom process
9289                         R_Bloom_CopyBloomTexture(r_bloom_colorscale.value);
9290                         // make the bloom texture
9291                         R_Bloom_MakeTexture();
9292                 }
9293
9294 #if _MSC_VER >= 1400
9295 #define sscanf sscanf_s
9296 #endif
9297                 memset(uservecs, 0, sizeof(uservecs));
9298                 sscanf(r_glsl_postprocess_uservec1.string, "%f %f %f %f", &uservecs[0][0], &uservecs[0][1], &uservecs[0][2], &uservecs[0][3]);
9299                 sscanf(r_glsl_postprocess_uservec2.string, "%f %f %f %f", &uservecs[1][0], &uservecs[1][1], &uservecs[1][2], &uservecs[1][3]);
9300                 sscanf(r_glsl_postprocess_uservec3.string, "%f %f %f %f", &uservecs[2][0], &uservecs[2][1], &uservecs[2][2], &uservecs[2][3]);
9301                 sscanf(r_glsl_postprocess_uservec4.string, "%f %f %f %f", &uservecs[3][0], &uservecs[3][1], &uservecs[3][2], &uservecs[3][3]);
9302
9303                 R_ResetViewRendering2D();
9304                 GL_Color(1, 1, 1, 1);
9305                 GL_BlendFunc(GL_ONE, GL_ZERO);
9306
9307                 switch(vid.renderpath)
9308                 {
9309                 case RENDERPATH_GL20:
9310                         R_Mesh_PrepareVertices_Mesh_Arrays(4, r_screenvertex3f, NULL, NULL, NULL, NULL, r_bloomstate.screentexcoord2f, r_bloomstate.bloomtexcoord2f);
9311                         R_SetupShader_SetPermutationGLSL(SHADERMODE_POSTPROCESS, permutation);
9312                         if (r_glsl_permutation->loc_Texture_First      >= 0) R_Mesh_TexBind(GL20TU_FIRST     , r_bloomstate.texture_screen);
9313                         if (r_glsl_permutation->loc_Texture_Second     >= 0) R_Mesh_TexBind(GL20TU_SECOND    , r_bloomstate.texture_bloom );
9314                         if (r_glsl_permutation->loc_Texture_GammaRamps >= 0) R_Mesh_TexBind(GL20TU_GAMMARAMPS, r_texture_gammaramps       );
9315                         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]);
9316                         if (r_glsl_permutation->loc_PixelSize          >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelSize         , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);
9317                         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]);
9318                         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]);
9319                         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]);
9320                         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]);
9321                         if (r_glsl_permutation->loc_Saturation         >= 0) qglUniform1fARB(r_glsl_permutation->loc_Saturation        , r_glsl_saturation.value);
9322                         if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
9323                         if (r_glsl_permutation->loc_BloomColorSubtract    >= 0) qglUniform4fARB(r_glsl_permutation->loc_BloomColorSubtract   , r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 0.0f);
9324                         break;
9325                 case RENDERPATH_CGGL:
9326 #ifdef SUPPORTCG
9327                         R_Mesh_PrepareVertices_Mesh_Arrays(4, r_screenvertex3f, NULL, NULL, NULL, NULL, r_bloomstate.screentexcoord2f, r_bloomstate.bloomtexcoord2f);
9328                         R_SetupShader_SetPermutationCG(SHADERMODE_POSTPROCESS, permutation);
9329                         if (r_cg_permutation->fp_Texture_First     ) CG_BindTexture(r_cg_permutation->fp_Texture_First     , r_bloomstate.texture_screen);CHECKCGERROR
9330                         if (r_cg_permutation->fp_Texture_Second    ) CG_BindTexture(r_cg_permutation->fp_Texture_Second    , r_bloomstate.texture_bloom );CHECKCGERROR
9331                         if (r_cg_permutation->fp_Texture_GammaRamps) CG_BindTexture(r_cg_permutation->fp_Texture_GammaRamps, r_texture_gammaramps       );CHECKCGERROR
9332                         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
9333                         if (r_cg_permutation->fp_PixelSize         ) cgGLSetParameter2f(     r_cg_permutation->fp_PixelSize         , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);CHECKCGERROR
9334                         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
9335                         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
9336                         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
9337                         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
9338                         if (r_cg_permutation->fp_Saturation        ) cgGLSetParameter1f(     r_cg_permutation->fp_Saturation        , r_glsl_saturation.value);CHECKCGERROR
9339                         if (r_cg_permutation->fp_PixelToScreenTexCoord) cgGLSetParameter2f(r_cg_permutation->fp_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);CHECKCGERROR
9340                         if (r_cg_permutation->fp_BloomColorSubtract   ) cgGLSetParameter4f(r_cg_permutation->fp_BloomColorSubtract   , r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 0.0f);
9341 #endif
9342                         break;
9343                 case RENDERPATH_D3D9:
9344 #ifdef SUPPORTD3D
9345                         // D3D has upside down Y coords, the easiest way to flip this is to flip the screen vertices rather than the texcoords, so we just use a different array for that...
9346                         R_Mesh_PrepareVertices_Mesh_Arrays(4, r_d3dscreenvertex3f, NULL, NULL, NULL, NULL, r_bloomstate.screentexcoord2f, r_bloomstate.bloomtexcoord2f);
9347                         R_SetupShader_SetPermutationHLSL(SHADERMODE_POSTPROCESS, permutation);
9348                         R_Mesh_TexBind(GL20TU_FIRST     , r_bloomstate.texture_screen);
9349                         R_Mesh_TexBind(GL20TU_SECOND    , r_bloomstate.texture_bloom );
9350                         R_Mesh_TexBind(GL20TU_GAMMARAMPS, r_texture_gammaramps       );
9351                         hlslPSSetParameter4f(D3DPSREGISTER_ViewTintColor        , r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
9352                         hlslPSSetParameter2f(D3DPSREGISTER_PixelSize            , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);
9353                         hlslPSSetParameter4f(D3DPSREGISTER_UserVec1             , uservecs[0][0], uservecs[0][1], uservecs[0][2], uservecs[0][3]);
9354                         hlslPSSetParameter4f(D3DPSREGISTER_UserVec2             , uservecs[1][0], uservecs[1][1], uservecs[1][2], uservecs[1][3]);
9355                         hlslPSSetParameter4f(D3DPSREGISTER_UserVec3             , uservecs[2][0], uservecs[2][1], uservecs[2][2], uservecs[2][3]);
9356                         hlslPSSetParameter4f(D3DPSREGISTER_UserVec4             , uservecs[3][0], uservecs[3][1], uservecs[3][2], uservecs[3][3]);
9357                         hlslPSSetParameter1f(D3DPSREGISTER_Saturation           , r_glsl_saturation.value);
9358                         hlslPSSetParameter2f(D3DPSREGISTER_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);
9359                         hlslPSSetParameter4f(D3DPSREGISTER_BloomColorSubtract   , r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 0.0f);
9360 #endif
9361                         break;
9362                 case RENDERPATH_D3D10:
9363                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
9364                         break;
9365                 case RENDERPATH_D3D11:
9366                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
9367                         break;
9368                 default:
9369                         break;
9370                 }
9371                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
9372                 r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
9373                 break;
9374         case RENDERPATH_GL13:
9375         case RENDERPATH_GL11:
9376                 if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
9377                 {
9378                         // apply a color tint to the whole view
9379                         R_ResetViewRendering2D();
9380                         GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
9381                         R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, NULL);
9382                         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9383                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
9384                         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
9385                 }
9386                 break;
9387         }
9388 }
9389
9390 matrix4x4_t r_waterscrollmatrix;
9391
9392 void R_UpdateFogColor(void) // needs to be called before HDR subrender too, as that changes colorscale!
9393 {
9394         if (r_refdef.fog_density)
9395         {
9396                 r_refdef.fogcolor[0] = r_refdef.fog_red;
9397                 r_refdef.fogcolor[1] = r_refdef.fog_green;
9398                 r_refdef.fogcolor[2] = r_refdef.fog_blue;
9399
9400                 Vector4Set(r_refdef.fogplane, 0, 0, 1, -r_refdef.fog_height);
9401                 r_refdef.fogplaneviewdist = DotProduct(r_refdef.fogplane, r_refdef.view.origin) + r_refdef.fogplane[3];
9402                 r_refdef.fogplaneviewabove = r_refdef.fogplaneviewdist >= 0;
9403                 r_refdef.fogheightfade = -0.5f/max(0.125f, r_refdef.fog_fadedepth);
9404
9405                 {
9406                         vec3_t fogvec;
9407                         VectorCopy(r_refdef.fogcolor, fogvec);
9408                         //   color.rgb *= ContrastBoost * SceneBrightness;
9409                         VectorScale(fogvec, r_refdef.view.colorscale, fogvec);
9410                         r_refdef.fogcolor[0] = bound(0.0f, fogvec[0], 1.0f);
9411                         r_refdef.fogcolor[1] = bound(0.0f, fogvec[1], 1.0f);
9412                         r_refdef.fogcolor[2] = bound(0.0f, fogvec[2], 1.0f);
9413                 }
9414         }
9415 }
9416
9417 void R_UpdateVariables(void)
9418 {
9419         R_Textures_Frame();
9420
9421         r_refdef.scene.ambient = r_ambient.value * (1.0f / 64.0f);
9422
9423         r_refdef.farclip = r_farclip_base.value;
9424         if (r_refdef.scene.worldmodel)
9425                 r_refdef.farclip += r_refdef.scene.worldmodel->radius * r_farclip_world.value * 2;
9426         r_refdef.nearclip = bound (0.001f, r_nearclip.value, r_refdef.farclip - 1.0f);
9427
9428         if (r_shadow_frontsidecasting.integer < 0 || r_shadow_frontsidecasting.integer > 1)
9429                 Cvar_SetValueQuick(&r_shadow_frontsidecasting, 1);
9430         r_refdef.polygonfactor = 0;
9431         r_refdef.polygonoffset = 0;
9432         r_refdef.shadowpolygonfactor = r_refdef.polygonfactor + r_shadow_polygonfactor.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
9433         r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_polygonoffset.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
9434
9435         r_refdef.scene.rtworld = r_shadow_realtime_world.integer != 0;
9436         r_refdef.scene.rtworldshadows = r_shadow_realtime_world_shadows.integer && vid.stencil;
9437         r_refdef.scene.rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer && r_dynamic.integer;
9438         r_refdef.scene.rtdlightshadows = r_refdef.scene.rtdlight && r_shadow_realtime_dlight_shadows.integer && vid.stencil;
9439         r_refdef.lightmapintensity = r_refdef.scene.rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
9440         if (FAKELIGHT_ENABLED)
9441         {
9442                 r_refdef.lightmapintensity *= r_fakelight_intensity.value;
9443         }
9444         if (r_showsurfaces.integer)
9445         {
9446                 r_refdef.scene.rtworld = false;
9447                 r_refdef.scene.rtworldshadows = false;
9448                 r_refdef.scene.rtdlight = false;
9449                 r_refdef.scene.rtdlightshadows = false;
9450                 r_refdef.lightmapintensity = 0;
9451         }
9452
9453         if (gamemode == GAME_NEHAHRA)
9454         {
9455                 if (gl_fogenable.integer)
9456                 {
9457                         r_refdef.oldgl_fogenable = true;
9458                         r_refdef.fog_density = gl_fogdensity.value;
9459                         r_refdef.fog_red = gl_fogred.value;
9460                         r_refdef.fog_green = gl_foggreen.value;
9461                         r_refdef.fog_blue = gl_fogblue.value;
9462                         r_refdef.fog_alpha = 1;
9463                         r_refdef.fog_start = 0;
9464                         r_refdef.fog_end = gl_skyclip.value;
9465                         r_refdef.fog_height = 1<<30;
9466                         r_refdef.fog_fadedepth = 128;
9467                 }
9468                 else if (r_refdef.oldgl_fogenable)
9469                 {
9470                         r_refdef.oldgl_fogenable = false;
9471                         r_refdef.fog_density = 0;
9472                         r_refdef.fog_red = 0;
9473                         r_refdef.fog_green = 0;
9474                         r_refdef.fog_blue = 0;
9475                         r_refdef.fog_alpha = 0;
9476                         r_refdef.fog_start = 0;
9477                         r_refdef.fog_end = 0;
9478                         r_refdef.fog_height = 1<<30;
9479                         r_refdef.fog_fadedepth = 128;
9480                 }
9481         }
9482
9483         r_refdef.fog_alpha = bound(0, r_refdef.fog_alpha, 1);
9484         r_refdef.fog_start = max(0, r_refdef.fog_start);
9485         r_refdef.fog_end = max(r_refdef.fog_start + 0.01, r_refdef.fog_end);
9486
9487         // R_UpdateFogColor(); // why? R_RenderScene does it anyway
9488
9489         if (r_refdef.fog_density && r_drawfog.integer)
9490         {
9491                 r_refdef.fogenabled = true;
9492                 // this is the point where the fog reaches 0.9986 alpha, which we
9493                 // consider a good enough cutoff point for the texture
9494                 // (0.9986 * 256 == 255.6)
9495                 if (r_fog_exp2.integer)
9496                         r_refdef.fogrange = 32 / (r_refdef.fog_density * r_refdef.fog_density) + r_refdef.fog_start;
9497                 else
9498                         r_refdef.fogrange = 2048 / r_refdef.fog_density + r_refdef.fog_start;
9499                 r_refdef.fogrange = bound(r_refdef.fog_start, r_refdef.fogrange, r_refdef.fog_end);
9500                 r_refdef.fograngerecip = 1.0f / r_refdef.fogrange;
9501                 r_refdef.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * r_refdef.fograngerecip;
9502                 if (strcmp(r_refdef.fogheighttexturename, r_refdef.fog_height_texturename))
9503                         R_BuildFogHeightTexture();
9504                 // fog color was already set
9505                 // update the fog texture
9506                 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)
9507                         R_BuildFogTexture();
9508                 r_refdef.fog_height_texcoordscale = 1.0f / max(0.125f, r_refdef.fog_fadedepth);
9509                 r_refdef.fog_height_tablescale = r_refdef.fog_height_tablesize * r_refdef.fog_height_texcoordscale;
9510         }
9511         else
9512                 r_refdef.fogenabled = false;
9513
9514         switch(vid.renderpath)
9515         {
9516         case RENDERPATH_GL20:
9517         case RENDERPATH_CGGL:
9518         case RENDERPATH_D3D9:
9519         case RENDERPATH_D3D10:
9520         case RENDERPATH_D3D11:
9521                 if(v_glslgamma.integer && !vid_gammatables_trivial)
9522                 {
9523                         if(!r_texture_gammaramps || vid_gammatables_serial != r_texture_gammaramps_serial)
9524                         {
9525                                 // build GLSL gamma texture
9526 #define RAMPWIDTH 256
9527                                 unsigned short ramp[RAMPWIDTH * 3];
9528                                 unsigned char rampbgr[RAMPWIDTH][4];
9529                                 int i;
9530
9531                                 r_texture_gammaramps_serial = vid_gammatables_serial;
9532
9533                                 VID_BuildGammaTables(&ramp[0], RAMPWIDTH);
9534                                 for(i = 0; i < RAMPWIDTH; ++i)
9535                                 {
9536                                         rampbgr[i][0] = (unsigned char) (ramp[i + 2 * RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
9537                                         rampbgr[i][1] = (unsigned char) (ramp[i + RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
9538                                         rampbgr[i][2] = (unsigned char) (ramp[i] * 255.0 / 65535.0 + 0.5);
9539                                         rampbgr[i][3] = 0;
9540                                 }
9541                                 if (r_texture_gammaramps)
9542                                 {
9543                                         R_UpdateTexture(r_texture_gammaramps, &rampbgr[0][0], 0, 0, RAMPWIDTH, 1);
9544                                 }
9545                                 else
9546                                 {
9547                                         r_texture_gammaramps = R_LoadTexture2D(r_main_texturepool, "gammaramps", RAMPWIDTH, 1, &rampbgr[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL);
9548                                 }
9549                         }
9550                 }
9551                 else
9552                 {
9553                         // remove GLSL gamma texture
9554                 }
9555                 break;
9556         case RENDERPATH_GL13:
9557         case RENDERPATH_GL11:
9558                 break;
9559         }
9560 }
9561
9562 static r_refdef_scene_type_t r_currentscenetype = RST_CLIENT;
9563 static r_refdef_scene_t r_scenes_store[ RST_COUNT ];
9564 /*
9565 ================
9566 R_SelectScene
9567 ================
9568 */
9569 void R_SelectScene( r_refdef_scene_type_t scenetype ) {
9570         if( scenetype != r_currentscenetype ) {
9571                 // store the old scenetype
9572                 r_scenes_store[ r_currentscenetype ] = r_refdef.scene;
9573                 r_currentscenetype = scenetype;
9574                 // move in the new scene
9575                 r_refdef.scene = r_scenes_store[ r_currentscenetype ];
9576         }
9577 }
9578
9579 /*
9580 ================
9581 R_GetScenePointer
9582 ================
9583 */
9584 r_refdef_scene_t * R_GetScenePointer( r_refdef_scene_type_t scenetype )
9585 {
9586         // of course, we could also add a qboolean that provides a lock state and a ReleaseScenePointer function..
9587         if( scenetype == r_currentscenetype ) {
9588                 return &r_refdef.scene;
9589         } else {
9590                 return &r_scenes_store[ scenetype ];
9591         }
9592 }
9593
9594 /*
9595 ================
9596 R_RenderView
9597 ================
9598 */
9599 void R_RenderView(void)
9600 {
9601         if (r_timereport_active)
9602                 R_TimeReport("start");
9603         r_textureframe++; // used only by R_GetCurrentTexture
9604         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
9605
9606         if(R_CompileShader_CheckStaticParms())
9607                 R_GLSL_Restart_f();
9608
9609         if (!r_drawentities.integer)
9610                 r_refdef.scene.numentities = 0;
9611
9612         R_AnimCache_ClearCache();
9613         R_FrameData_NewFrame();
9614
9615         if (r_refdef.view.isoverlay)
9616         {
9617                 // TODO: FIXME: move this into its own backend function maybe? [2/5/2008 Andreas]
9618                 GL_Clear(GL_DEPTH_BUFFER_BIT, NULL, 1.0f, 0);
9619                 R_TimeReport("depthclear");
9620
9621                 r_refdef.view.showdebug = false;
9622
9623                 r_waterstate.enabled = false;
9624                 r_waterstate.numwaterplanes = 0;
9625
9626                 R_RenderScene();
9627
9628                 CHECKGLERROR
9629                 return;
9630         }
9631
9632         if (!r_refdef.scene.entities || r_refdef.view.width * r_refdef.view.height == 0 || !r_renderview.integer || cl_videoplaying/* || !r_refdef.scene.worldmodel*/)
9633                 return; //Host_Error ("R_RenderView: NULL worldmodel");
9634
9635         r_refdef.view.colorscale = r_hdr_scenebrightness.value;
9636
9637         R_RenderView_UpdateViewVectors();
9638
9639         R_Shadow_UpdateWorldLightSelection();
9640
9641         R_Bloom_StartFrame();
9642         R_Water_StartFrame();
9643
9644         CHECKGLERROR
9645         if (r_timereport_active)
9646                 R_TimeReport("viewsetup");
9647
9648         R_ResetViewRendering3D();
9649
9650         if (r_refdef.view.clear || r_refdef.fogenabled)
9651         {
9652                 R_ClearScreen(r_refdef.fogenabled);
9653                 if (r_timereport_active)
9654                         R_TimeReport("viewclear");
9655         }
9656         r_refdef.view.clear = true;
9657
9658         // this produces a bloom texture to be used in R_BlendView() later
9659         if (r_hdr.integer && r_bloomstate.bloomwidth)
9660         {
9661                 R_HDR_RenderBloomTexture();
9662                 // we have to bump the texture frame again because r_refdef.view.colorscale is cached in the textures
9663                 r_textureframe++; // used only by R_GetCurrentTexture
9664         }
9665
9666         r_refdef.view.showdebug = true;
9667
9668         R_View_Update();
9669         if (r_timereport_active)
9670                 R_TimeReport("visibility");
9671
9672         r_waterstate.numwaterplanes = 0;
9673         if (r_waterstate.enabled)
9674                 R_RenderWaterPlanes();
9675
9676         R_RenderScene();
9677         r_waterstate.numwaterplanes = 0;
9678
9679         R_BlendView();
9680         if (r_timereport_active)
9681                 R_TimeReport("blendview");
9682
9683         GL_Scissor(0, 0, vid.width, vid.height);
9684         GL_ScissorTest(false);
9685
9686         CHECKGLERROR
9687 }
9688
9689 void R_RenderWaterPlanes(void)
9690 {
9691         if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawAddWaterPlanes)
9692         {
9693                 r_refdef.scene.worldmodel->DrawAddWaterPlanes(r_refdef.scene.worldentity);
9694                 if (r_timereport_active)
9695                         R_TimeReport("waterworld");
9696         }
9697
9698         // don't let sound skip if going slow
9699         if (r_refdef.scene.extraupdate)
9700                 S_ExtraUpdate ();
9701
9702         R_DrawModelsAddWaterPlanes();
9703         if (r_timereport_active)
9704                 R_TimeReport("watermodels");
9705
9706         if (r_waterstate.numwaterplanes)
9707         {
9708                 R_Water_ProcessPlanes();
9709                 if (r_timereport_active)
9710                         R_TimeReport("waterscenes");
9711         }
9712 }
9713
9714 extern void R_DrawLightningBeams (void);
9715 extern void VM_CL_AddPolygonsToMeshQueue (void);
9716 extern void R_DrawPortals (void);
9717 extern cvar_t cl_locs_show;
9718 static void R_DrawLocs(void);
9719 static void R_DrawEntityBBoxes(void);
9720 static void R_DrawModelDecals(void);
9721 extern void R_DrawModelShadows(void);
9722 extern void R_DrawModelShadowMaps(void);
9723 extern cvar_t cl_decals_newsystem;
9724 extern qboolean r_shadow_usingdeferredprepass;
9725 void R_RenderScene(void)
9726 {
9727         qboolean shadowmapping = false;
9728
9729         if (r_timereport_active)
9730                 R_TimeReport("beginscene");
9731
9732         r_refdef.stats.renders++;
9733
9734         R_UpdateFogColor();
9735
9736         // don't let sound skip if going slow
9737         if (r_refdef.scene.extraupdate)
9738                 S_ExtraUpdate ();
9739
9740         R_MeshQueue_BeginScene();
9741
9742         R_SkyStartFrame();
9743
9744         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);
9745
9746         if (r_timereport_active)
9747                 R_TimeReport("skystartframe");
9748
9749         if (cl.csqc_vidvars.drawworld)
9750         {
9751                 // don't let sound skip if going slow
9752                 if (r_refdef.scene.extraupdate)
9753                         S_ExtraUpdate ();
9754
9755                 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawSky)
9756                 {
9757                         r_refdef.scene.worldmodel->DrawSky(r_refdef.scene.worldentity);
9758                         if (r_timereport_active)
9759                                 R_TimeReport("worldsky");
9760                 }
9761
9762                 if (R_DrawBrushModelsSky() && r_timereport_active)
9763                         R_TimeReport("bmodelsky");
9764
9765                 if (skyrendermasked && skyrenderlater)
9766                 {
9767                         // we have to force off the water clipping plane while rendering sky
9768                         R_SetupView(false);
9769                         R_Sky();
9770                         R_SetupView(true);
9771                         if (r_timereport_active)
9772                                 R_TimeReport("sky");
9773                 }
9774         }
9775
9776         R_AnimCache_CacheVisibleEntities();
9777         if (r_timereport_active)
9778                 R_TimeReport("animation");
9779
9780         R_Shadow_PrepareLights();
9781         if (r_shadows.integer > 0 && r_refdef.lightmapintensity > 0)
9782                 R_Shadow_PrepareModelShadows();
9783         if (r_timereport_active)
9784                 R_TimeReport("preparelights");
9785
9786         if (R_Shadow_ShadowMappingEnabled())
9787                 shadowmapping = true;
9788
9789         if (r_shadow_usingdeferredprepass)
9790                 R_Shadow_DrawPrepass();
9791
9792         if (r_depthfirst.integer >= 1 && cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawDepth)
9793         {
9794                 r_refdef.scene.worldmodel->DrawDepth(r_refdef.scene.worldentity);
9795                 if (r_timereport_active)
9796                         R_TimeReport("worlddepth");
9797         }
9798         if (r_depthfirst.integer >= 2)
9799         {
9800                 R_DrawModelsDepth();
9801                 if (r_timereport_active)
9802                         R_TimeReport("modeldepth");
9803         }
9804
9805         if (r_shadows.integer >= 2 && shadowmapping && r_refdef.lightmapintensity > 0)
9806         {
9807                 R_DrawModelShadowMaps();
9808                 R_ResetViewRendering3D();
9809                 // don't let sound skip if going slow
9810                 if (r_refdef.scene.extraupdate)
9811                         S_ExtraUpdate ();
9812         }
9813
9814         if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->Draw)
9815         {
9816                 r_refdef.scene.worldmodel->Draw(r_refdef.scene.worldentity);
9817                 if (r_timereport_active)
9818                         R_TimeReport("world");
9819         }
9820
9821         // don't let sound skip if going slow
9822         if (r_refdef.scene.extraupdate)
9823                 S_ExtraUpdate ();
9824
9825         R_DrawModels();
9826         if (r_timereport_active)
9827                 R_TimeReport("models");
9828
9829         // don't let sound skip if going slow
9830         if (r_refdef.scene.extraupdate)
9831                 S_ExtraUpdate ();
9832
9833         if ((r_shadows.integer == 1 || (r_shadows.integer > 0 && !shadowmapping)) && !r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0)
9834         {
9835                 R_DrawModelShadows();
9836                 R_ResetViewRendering3D();
9837                 // don't let sound skip if going slow
9838                 if (r_refdef.scene.extraupdate)
9839                         S_ExtraUpdate ();
9840         }
9841
9842         if (!r_shadow_usingdeferredprepass)
9843         {
9844                 R_Shadow_DrawLights();
9845                 if (r_timereport_active)
9846                         R_TimeReport("rtlights");
9847         }
9848
9849         // don't let sound skip if going slow
9850         if (r_refdef.scene.extraupdate)
9851                 S_ExtraUpdate ();
9852
9853         if ((r_shadows.integer == 1 || (r_shadows.integer > 0 && !shadowmapping)) && r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0)
9854         {
9855                 R_DrawModelShadows();
9856                 R_ResetViewRendering3D();
9857                 // don't let sound skip if going slow
9858                 if (r_refdef.scene.extraupdate)
9859                         S_ExtraUpdate ();
9860         }
9861
9862         if (cl.csqc_vidvars.drawworld)
9863         {
9864                 if (cl_decals_newsystem.integer)
9865                 {
9866                         R_DrawModelDecals();
9867                         if (r_timereport_active)
9868                                 R_TimeReport("modeldecals");
9869                 }
9870                 else
9871                 {
9872                         R_DrawDecals();
9873                         if (r_timereport_active)
9874                                 R_TimeReport("decals");
9875                 }
9876
9877                 R_DrawParticles();
9878                 if (r_timereport_active)
9879                         R_TimeReport("particles");
9880
9881                 R_DrawExplosions();
9882                 if (r_timereport_active)
9883                         R_TimeReport("explosions");
9884
9885                 R_DrawLightningBeams();
9886                 if (r_timereport_active)
9887                         R_TimeReport("lightning");
9888         }
9889
9890         VM_CL_AddPolygonsToMeshQueue();
9891
9892         if (r_refdef.view.showdebug)
9893         {
9894                 if (cl_locs_show.integer)
9895                 {
9896                         R_DrawLocs();
9897                         if (r_timereport_active)
9898                                 R_TimeReport("showlocs");
9899                 }
9900
9901                 if (r_drawportals.integer)
9902                 {
9903                         R_DrawPortals();
9904                         if (r_timereport_active)
9905                                 R_TimeReport("portals");
9906                 }
9907
9908                 if (r_showbboxes.value > 0)
9909                 {
9910                         R_DrawEntityBBoxes();
9911                         if (r_timereport_active)
9912                                 R_TimeReport("bboxes");
9913                 }
9914         }
9915
9916         R_MeshQueue_RenderTransparent();
9917         if (r_timereport_active)
9918                 R_TimeReport("drawtrans");
9919
9920         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))
9921         {
9922                 r_refdef.scene.worldmodel->DrawDebug(r_refdef.scene.worldentity);
9923                 if (r_timereport_active)
9924                         R_TimeReport("worlddebug");
9925                 R_DrawModelsDebug();
9926                 if (r_timereport_active)
9927                         R_TimeReport("modeldebug");
9928         }
9929
9930         if (cl.csqc_vidvars.drawworld)
9931         {
9932                 R_Shadow_DrawCoronas();
9933                 if (r_timereport_active)
9934                         R_TimeReport("coronas");
9935         }
9936
9937 #if 0
9938         {
9939                 GL_DepthTest(false);
9940                 qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
9941                 GL_Color(1, 1, 1, 1);
9942                 qglBegin(GL_POLYGON);
9943                 qglVertex3f(r_refdef.view.frustumcorner[0][0], r_refdef.view.frustumcorner[0][1], r_refdef.view.frustumcorner[0][2]);
9944                 qglVertex3f(r_refdef.view.frustumcorner[1][0], r_refdef.view.frustumcorner[1][1], r_refdef.view.frustumcorner[1][2]);
9945                 qglVertex3f(r_refdef.view.frustumcorner[3][0], r_refdef.view.frustumcorner[3][1], r_refdef.view.frustumcorner[3][2]);
9946                 qglVertex3f(r_refdef.view.frustumcorner[2][0], r_refdef.view.frustumcorner[2][1], r_refdef.view.frustumcorner[2][2]);
9947                 qglEnd();
9948                 qglBegin(GL_POLYGON);
9949                 qglVertex3f(r_refdef.view.frustumcorner[0][0] + 1000 * r_refdef.view.forward[0], r_refdef.view.frustumcorner[0][1] + 1000 * r_refdef.view.forward[1], r_refdef.view.frustumcorner[0][2] + 1000 * r_refdef.view.forward[2]);
9950                 qglVertex3f(r_refdef.view.frustumcorner[1][0] + 1000 * r_refdef.view.forward[0], r_refdef.view.frustumcorner[1][1] + 1000 * r_refdef.view.forward[1], r_refdef.view.frustumcorner[1][2] + 1000 * r_refdef.view.forward[2]);
9951                 qglVertex3f(r_refdef.view.frustumcorner[3][0] + 1000 * r_refdef.view.forward[0], r_refdef.view.frustumcorner[3][1] + 1000 * r_refdef.view.forward[1], r_refdef.view.frustumcorner[3][2] + 1000 * r_refdef.view.forward[2]);
9952                 qglVertex3f(r_refdef.view.frustumcorner[2][0] + 1000 * r_refdef.view.forward[0], r_refdef.view.frustumcorner[2][1] + 1000 * r_refdef.view.forward[1], r_refdef.view.frustumcorner[2][2] + 1000 * r_refdef.view.forward[2]);
9953                 qglEnd();
9954                 qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
9955         }
9956 #endif
9957
9958         // don't let sound skip if going slow
9959         if (r_refdef.scene.extraupdate)
9960                 S_ExtraUpdate ();
9961
9962         R_ResetViewRendering2D();
9963 }
9964
9965 static const unsigned short bboxelements[36] =
9966 {
9967         5, 1, 3, 5, 3, 7,
9968         6, 2, 0, 6, 0, 4,
9969         7, 3, 2, 7, 2, 6,
9970         4, 0, 1, 4, 1, 5,
9971         4, 5, 7, 4, 7, 6,
9972         1, 0, 2, 1, 2, 3,
9973 };
9974
9975 void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
9976 {
9977         int i;
9978         float *v, *c, f1, f2, vertex3f[8*3], color4f[8*4];
9979
9980         RSurf_ActiveWorldEntity();
9981
9982         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
9983         GL_DepthMask(false);
9984         GL_DepthRange(0, 1);
9985         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
9986         R_Mesh_ResetTextureState();
9987
9988         vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2]; //
9989         vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2];
9990         vertex3f[ 6] = mins[0];vertex3f[ 7] = maxs[1];vertex3f[ 8] = mins[2];
9991         vertex3f[ 9] = maxs[0];vertex3f[10] = maxs[1];vertex3f[11] = mins[2];
9992         vertex3f[12] = mins[0];vertex3f[13] = mins[1];vertex3f[14] = maxs[2];
9993         vertex3f[15] = maxs[0];vertex3f[16] = mins[1];vertex3f[17] = maxs[2];
9994         vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
9995         vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
9996         R_FillColors(color4f, 8, cr, cg, cb, ca);
9997         if (r_refdef.fogenabled)
9998         {
9999                 for (i = 0, v = vertex3f, c = color4f;i < 8;i++, v += 3, c += 4)
10000                 {
10001                         f1 = RSurf_FogVertex(v);
10002                         f2 = 1 - f1;
10003                         c[0] = c[0] * f1 + r_refdef.fogcolor[0] * f2;
10004                         c[1] = c[1] * f1 + r_refdef.fogcolor[1] * f2;
10005                         c[2] = c[2] * f1 + r_refdef.fogcolor[2] * f2;
10006                 }
10007         }
10008         R_Mesh_PrepareVertices_Generic_Arrays(8, vertex3f, color4f, NULL);
10009         R_Mesh_ResetTextureState();
10010         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
10011         R_Mesh_Draw(0, 8, 0, 12, NULL, NULL, 0, bboxelements, NULL, 0);
10012 }
10013
10014 static void R_DrawEntityBBoxes_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
10015 {
10016         int i;
10017         float color[4];
10018         prvm_edict_t *edict;
10019         prvm_prog_t *prog_save = prog;
10020
10021         // this function draws bounding boxes of server entities
10022         if (!sv.active)
10023                 return;
10024
10025         GL_CullFace(GL_NONE);
10026         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
10027
10028         prog = 0;
10029         SV_VM_Begin();
10030         for (i = 0;i < numsurfaces;i++)
10031         {
10032                 edict = PRVM_EDICT_NUM(surfacelist[i]);
10033                 switch ((int)edict->fields.server->solid)
10034                 {
10035                         case SOLID_NOT:      Vector4Set(color, 1, 1, 1, 0.05);break;
10036                         case SOLID_TRIGGER:  Vector4Set(color, 1, 0, 1, 0.10);break;
10037                         case SOLID_BBOX:     Vector4Set(color, 0, 1, 0, 0.10);break;
10038                         case SOLID_SLIDEBOX: Vector4Set(color, 1, 0, 0, 0.10);break;
10039                         case SOLID_BSP:      Vector4Set(color, 0, 0, 1, 0.05);break;
10040                         default:             Vector4Set(color, 0, 0, 0, 0.50);break;
10041                 }
10042                 color[3] *= r_showbboxes.value;
10043                 color[3] = bound(0, color[3], 1);
10044                 GL_DepthTest(!r_showdisabledepthtest.integer);
10045                 GL_CullFace(r_refdef.view.cullface_front);
10046                 R_DrawBBoxMesh(edict->priv.server->areamins, edict->priv.server->areamaxs, color[0], color[1], color[2], color[3]);
10047         }
10048         SV_VM_End();
10049         prog = prog_save;
10050 }
10051
10052 static void R_DrawEntityBBoxes(void)
10053 {
10054         int i;
10055         prvm_edict_t *edict;
10056         vec3_t center;
10057         prvm_prog_t *prog_save = prog;
10058
10059         // this function draws bounding boxes of server entities
10060         if (!sv.active)
10061                 return;
10062
10063         prog = 0;
10064         SV_VM_Begin();
10065         for (i = 0;i < prog->num_edicts;i++)
10066         {
10067                 edict = PRVM_EDICT_NUM(i);
10068                 if (edict->priv.server->free)
10069                         continue;
10070                 // exclude the following for now, as they don't live in world coordinate space and can't be solid:
10071                 if(PRVM_EDICTFIELDVALUE(edict, prog->fieldoffsets.tag_entity)->edict != 0)
10072                         continue;
10073                 if(PRVM_EDICTFIELDVALUE(edict, prog->fieldoffsets.viewmodelforclient)->edict != 0)
10074                         continue;
10075                 VectorLerp(edict->priv.server->areamins, 0.5f, edict->priv.server->areamaxs, center);
10076                 R_MeshQueue_AddTransparent(center, R_DrawEntityBBoxes_Callback, (entity_render_t *)NULL, i, (rtlight_t *)NULL);
10077         }
10078         SV_VM_End();
10079         prog = prog_save;
10080 }
10081
10082 static const int nomodelelement3i[24] =
10083 {
10084         5, 2, 0,
10085         5, 1, 2,
10086         5, 0, 3,
10087         5, 3, 1,
10088         0, 2, 4,
10089         2, 1, 4,
10090         3, 0, 4,
10091         1, 3, 4
10092 };
10093
10094 static const unsigned short nomodelelement3s[24] =
10095 {
10096         5, 2, 0,
10097         5, 1, 2,
10098         5, 0, 3,
10099         5, 3, 1,
10100         0, 2, 4,
10101         2, 1, 4,
10102         3, 0, 4,
10103         1, 3, 4
10104 };
10105
10106 static const float nomodelvertex3f[6*3] =
10107 {
10108         -16,   0,   0,
10109          16,   0,   0,
10110           0, -16,   0,
10111           0,  16,   0,
10112           0,   0, -16,
10113           0,   0,  16
10114 };
10115
10116 static const float nomodelcolor4f[6*4] =
10117 {
10118         0.0f, 0.0f, 0.5f, 1.0f,
10119         0.0f, 0.0f, 0.5f, 1.0f,
10120         0.0f, 0.5f, 0.0f, 1.0f,
10121         0.0f, 0.5f, 0.0f, 1.0f,
10122         0.5f, 0.0f, 0.0f, 1.0f,
10123         0.5f, 0.0f, 0.0f, 1.0f
10124 };
10125
10126 void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
10127 {
10128         int i;
10129         float f1, f2, *c;
10130         float color4f[6*4];
10131
10132         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);
10133
10134         // this is only called once per entity so numsurfaces is always 1, and
10135         // surfacelist is always {0}, so this code does not handle batches
10136
10137         if (rsurface.ent_flags & RENDER_ADDITIVE)
10138         {
10139                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
10140                 GL_DepthMask(false);
10141         }
10142         else if (rsurface.colormod[3] < 1)
10143         {
10144                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
10145                 GL_DepthMask(false);
10146         }
10147         else
10148         {
10149                 GL_BlendFunc(GL_ONE, GL_ZERO);
10150                 GL_DepthMask(true);
10151         }
10152         GL_DepthRange(0, (rsurface.ent_flags & RENDER_VIEWMODEL) ? 0.0625 : 1);
10153         GL_PolygonOffset(rsurface.basepolygonfactor, rsurface.basepolygonoffset);
10154         GL_DepthTest(!(rsurface.ent_flags & RENDER_NODEPTHTEST));
10155         GL_CullFace((rsurface.ent_flags & RENDER_DOUBLESIDED) ? GL_NONE : r_refdef.view.cullface_back);
10156         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
10157         memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
10158         for (i = 0, c = color4f;i < 6;i++, c += 4)
10159         {
10160                 c[0] *= rsurface.colormod[0];
10161                 c[1] *= rsurface.colormod[1];
10162                 c[2] *= rsurface.colormod[2];
10163                 c[3] *= rsurface.colormod[3];
10164         }
10165         if (r_refdef.fogenabled)
10166         {
10167                 for (i = 0, c = color4f;i < 6;i++, c += 4)
10168                 {
10169                         f1 = RSurf_FogVertex(nomodelvertex3f + 3*i);
10170                         f2 = 1 - f1;
10171                         c[0] = (c[0] * f1 + r_refdef.fogcolor[0] * f2);
10172                         c[1] = (c[1] * f1 + r_refdef.fogcolor[1] * f2);
10173                         c[2] = (c[2] * f1 + r_refdef.fogcolor[2] * f2);
10174                 }
10175         }
10176         R_Mesh_ResetTextureState();
10177         R_Mesh_PrepareVertices_Generic_Arrays(6, nomodelvertex3f, color4f, NULL);
10178         R_Mesh_Draw(0, 6, 0, 8, nomodelelement3i, NULL, 0, nomodelelement3s, NULL, 0);
10179 }
10180
10181 void R_DrawNoModel(entity_render_t *ent)
10182 {
10183         vec3_t org;
10184         Matrix4x4_OriginFromMatrix(&ent->matrix, org);
10185         if ((ent->flags & RENDER_ADDITIVE) || (ent->alpha < 1))
10186                 R_MeshQueue_AddTransparent(ent->flags & RENDER_NODEPTHTEST ? r_refdef.view.origin : org, R_DrawNoModel_TransparentCallback, ent, 0, rsurface.rtlight);
10187         else
10188                 R_DrawNoModel_TransparentCallback(ent, rsurface.rtlight, 0, NULL);
10189 }
10190
10191 void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
10192 {
10193         vec3_t right1, right2, diff, normal;
10194
10195         VectorSubtract (org2, org1, normal);
10196
10197         // calculate 'right' vector for start
10198         VectorSubtract (r_refdef.view.origin, org1, diff);
10199         CrossProduct (normal, diff, right1);
10200         VectorNormalize (right1);
10201
10202         // calculate 'right' vector for end
10203         VectorSubtract (r_refdef.view.origin, org2, diff);
10204         CrossProduct (normal, diff, right2);
10205         VectorNormalize (right2);
10206
10207         vert[ 0] = org1[0] + width * right1[0];
10208         vert[ 1] = org1[1] + width * right1[1];
10209         vert[ 2] = org1[2] + width * right1[2];
10210         vert[ 3] = org1[0] - width * right1[0];
10211         vert[ 4] = org1[1] - width * right1[1];
10212         vert[ 5] = org1[2] - width * right1[2];
10213         vert[ 6] = org2[0] - width * right2[0];
10214         vert[ 7] = org2[1] - width * right2[1];
10215         vert[ 8] = org2[2] - width * right2[2];
10216         vert[ 9] = org2[0] + width * right2[0];
10217         vert[10] = org2[1] + width * right2[1];
10218         vert[11] = org2[2] + width * right2[2];
10219 }
10220
10221 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)
10222 {
10223         vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
10224         vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
10225         vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
10226         vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
10227         vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
10228         vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
10229         vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
10230         vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
10231         vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
10232         vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
10233         vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
10234         vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
10235 }
10236
10237 int R_Mesh_AddVertex(rmesh_t *mesh, float x, float y, float z)
10238 {
10239         int i;
10240         float *vertex3f;
10241         float v[3];
10242         VectorSet(v, x, y, z);
10243         for (i = 0, vertex3f = mesh->vertex3f;i < mesh->numvertices;i++, vertex3f += 3)
10244                 if (VectorDistance2(v, vertex3f) < mesh->epsilon2)
10245                         break;
10246         if (i == mesh->numvertices)
10247         {
10248                 if (mesh->numvertices < mesh->maxvertices)
10249                 {
10250                         VectorCopy(v, vertex3f);
10251                         mesh->numvertices++;
10252                 }
10253                 return mesh->numvertices;
10254         }
10255         else
10256                 return i;
10257 }
10258
10259 void R_Mesh_AddPolygon3f(rmesh_t *mesh, int numvertices, float *vertex3f)
10260 {
10261         int i;
10262         int *e, element[3];
10263         element[0] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
10264         element[1] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
10265         e = mesh->element3i + mesh->numtriangles * 3;
10266         for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
10267         {
10268                 element[2] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);
10269                 if (mesh->numtriangles < mesh->maxtriangles)
10270                 {
10271                         *e++ = element[0];
10272                         *e++ = element[1];
10273                         *e++ = element[2];
10274                         mesh->numtriangles++;
10275                 }
10276                 element[1] = element[2];
10277         }
10278 }
10279
10280 void R_Mesh_AddPolygon3d(rmesh_t *mesh, int numvertices, double *vertex3d)
10281 {
10282         int i;
10283         int *e, element[3];
10284         element[0] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
10285         element[1] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
10286         e = mesh->element3i + mesh->numtriangles * 3;
10287         for (i = 0;i < numvertices - 2;i++, vertex3d += 3)
10288         {
10289                 element[2] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);
10290                 if (mesh->numtriangles < mesh->maxtriangles)
10291                 {
10292                         *e++ = element[0];
10293                         *e++ = element[1];
10294                         *e++ = element[2];
10295                         mesh->numtriangles++;
10296                 }
10297                 element[1] = element[2];
10298         }
10299 }
10300
10301 #define R_MESH_PLANE_DIST_EPSILON (1.0 / 32.0)
10302 void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes)
10303 {
10304         int planenum, planenum2;
10305         int w;
10306         int tempnumpoints;
10307         mplane_t *plane, *plane2;
10308         double maxdist;
10309         double temppoints[2][256*3];
10310         // figure out how large a bounding box we need to properly compute this brush
10311         maxdist = 0;
10312         for (w = 0;w < numplanes;w++)
10313                 maxdist = max(maxdist, fabs(planes[w].dist));
10314         // now make it large enough to enclose the entire brush, and round it off to a reasonable multiple of 1024
10315         maxdist = floor(maxdist * (4.0 / 1024.0) + 1) * 1024.0;
10316         for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
10317         {
10318                 w = 0;
10319                 tempnumpoints = 4;
10320                 PolygonD_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, maxdist);
10321                 for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
10322                 {
10323                         if (planenum2 == planenum)
10324                                 continue;
10325                         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);
10326                         w = !w;
10327                 }
10328                 if (tempnumpoints < 3)
10329                         continue;
10330                 // generate elements forming a triangle fan for this polygon
10331                 R_Mesh_AddPolygon3d(mesh, tempnumpoints, temppoints[w]);
10332         }
10333 }
10334
10335 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)
10336 {
10337         texturelayer_t *layer;
10338         layer = t->currentlayers + t->currentnumlayers++;
10339         layer->type = type;
10340         layer->depthmask = depthmask;
10341         layer->blendfunc1 = blendfunc1;
10342         layer->blendfunc2 = blendfunc2;
10343         layer->texture = texture;
10344         layer->texmatrix = *matrix;
10345         layer->color[0] = r;
10346         layer->color[1] = g;
10347         layer->color[2] = b;
10348         layer->color[3] = a;
10349 }
10350
10351 static qboolean R_TestQ3WaveFunc(q3wavefunc_t func, const float *parms)
10352 {
10353         if(parms[0] == 0 && parms[1] == 0)
10354                 return false;
10355         if(func >> Q3WAVEFUNC_USER_SHIFT) // assumes rsurface to be set!
10356                 if(rsurface.userwavefunc_param[bound(0, (func >> Q3WAVEFUNC_USER_SHIFT) - 1, Q3WAVEFUNC_USER_COUNT)] == 0)
10357                         return false;
10358         return true;
10359 }
10360
10361 static float R_EvaluateQ3WaveFunc(q3wavefunc_t func, const float *parms)
10362 {
10363         double index, f;
10364         index = parms[2] + r_refdef.scene.time * parms[3];
10365         index -= floor(index);
10366         switch (func & ((1 << Q3WAVEFUNC_USER_SHIFT) - 1))
10367         {
10368         default:
10369         case Q3WAVEFUNC_NONE:
10370         case Q3WAVEFUNC_NOISE:
10371         case Q3WAVEFUNC_COUNT:
10372                 f = 0;
10373                 break;
10374         case Q3WAVEFUNC_SIN: f = sin(index * M_PI * 2);break;
10375         case Q3WAVEFUNC_SQUARE: f = index < 0.5 ? 1 : -1;break;
10376         case Q3WAVEFUNC_SAWTOOTH: f = index;break;
10377         case Q3WAVEFUNC_INVERSESAWTOOTH: f = 1 - index;break;
10378         case Q3WAVEFUNC_TRIANGLE:
10379                 index *= 4;
10380                 f = index - floor(index);
10381                 if (index < 1)
10382                         f = f;
10383                 else if (index < 2)
10384                         f = 1 - f;
10385                 else if (index < 3)
10386                         f = -f;
10387                 else
10388                         f = -(1 - f);
10389                 break;
10390         }
10391         f = parms[0] + parms[1] * f;
10392         if(func >> Q3WAVEFUNC_USER_SHIFT) // assumes rsurface to be set!
10393                 f *= rsurface.userwavefunc_param[bound(0, (func >> Q3WAVEFUNC_USER_SHIFT) - 1, Q3WAVEFUNC_USER_COUNT)];
10394         return (float) f;
10395 }
10396
10397 void R_tcMod_ApplyToMatrix(matrix4x4_t *texmatrix, q3shaderinfo_layer_tcmod_t *tcmod, int currentmaterialflags)
10398 {
10399         int w, h, idx;
10400         float f;
10401         float tcmat[12];
10402         matrix4x4_t matrix, temp;
10403         switch(tcmod->tcmod)
10404         {
10405                 case Q3TCMOD_COUNT:
10406                 case Q3TCMOD_NONE:
10407                         if (currentmaterialflags & MATERIALFLAG_WATERSCROLL)
10408                                 matrix = r_waterscrollmatrix;
10409                         else
10410                                 matrix = identitymatrix;
10411                         break;
10412                 case Q3TCMOD_ENTITYTRANSLATE:
10413                         // this is used in Q3 to allow the gamecode to control texcoord
10414                         // scrolling on the entity, which is not supported in darkplaces yet.
10415                         Matrix4x4_CreateTranslate(&matrix, 0, 0, 0);
10416                         break;
10417                 case Q3TCMOD_ROTATE:
10418                         Matrix4x4_CreateTranslate(&matrix, 0.5, 0.5, 0);
10419                         Matrix4x4_ConcatRotate(&matrix, tcmod->parms[0] * r_refdef.scene.time, 0, 0, 1);
10420                         Matrix4x4_ConcatTranslate(&matrix, -0.5, -0.5, 0);
10421                         break;
10422                 case Q3TCMOD_SCALE:
10423                         Matrix4x4_CreateScale3(&matrix, tcmod->parms[0], tcmod->parms[1], 1);
10424                         break;
10425                 case Q3TCMOD_SCROLL:
10426                         Matrix4x4_CreateTranslate(&matrix, tcmod->parms[0] * r_refdef.scene.time, tcmod->parms[1] * r_refdef.scene.time, 0);
10427                         break;
10428                 case Q3TCMOD_PAGE: // poor man's animmap (to store animations into a single file, useful for HTTP downloaded textures)
10429                         w = (int) tcmod->parms[0];
10430                         h = (int) tcmod->parms[1];
10431                         f = r_refdef.scene.time / (tcmod->parms[2] * w * h);
10432                         f = f - floor(f);
10433                         idx = (int) floor(f * w * h);
10434                         Matrix4x4_CreateTranslate(&matrix, (idx % w) / tcmod->parms[0], (idx / w) / tcmod->parms[1], 0);
10435                         break;
10436                 case Q3TCMOD_STRETCH:
10437                         f = 1.0f / R_EvaluateQ3WaveFunc(tcmod->wavefunc, tcmod->waveparms);
10438                         Matrix4x4_CreateFromQuakeEntity(&matrix, 0.5f * (1 - f), 0.5 * (1 - f), 0, 0, 0, 0, f);
10439                         break;
10440                 case Q3TCMOD_TRANSFORM:
10441                         VectorSet(tcmat +  0, tcmod->parms[0], tcmod->parms[1], 0);
10442                         VectorSet(tcmat +  3, tcmod->parms[2], tcmod->parms[3], 0);
10443                         VectorSet(tcmat +  6, 0                   , 0                , 1);
10444                         VectorSet(tcmat +  9, tcmod->parms[4], tcmod->parms[5], 0);
10445                         Matrix4x4_FromArray12FloatGL(&matrix, tcmat);
10446                         break;
10447                 case Q3TCMOD_TURBULENT:
10448                         // this is handled in the RSurf_PrepareVertices function
10449                         matrix = identitymatrix;
10450                         break;
10451         }
10452         temp = *texmatrix;
10453         Matrix4x4_Concat(texmatrix, &matrix, &temp);
10454 }
10455
10456 void R_LoadQWSkin(r_qwskincache_t *cache, const char *skinname)
10457 {
10458         int textureflags = (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_PICMIP | TEXF_COMPRESS;
10459         char name[MAX_QPATH];
10460         skinframe_t *skinframe;
10461         unsigned char pixels[296*194];
10462         strlcpy(cache->name, skinname, sizeof(cache->name));
10463         dpsnprintf(name, sizeof(name), "skins/%s.pcx", cache->name);
10464         if (developer_loading.integer)
10465                 Con_Printf("loading %s\n", name);
10466         skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
10467         if (!skinframe || !skinframe->base)
10468         {
10469                 unsigned char *f;
10470                 fs_offset_t filesize;
10471                 skinframe = NULL;
10472                 f = FS_LoadFile(name, tempmempool, true, &filesize);
10473                 if (f)
10474                 {
10475                         if (LoadPCX_QWSkin(f, (int)filesize, pixels, 296, 194))
10476                                 skinframe = R_SkinFrame_LoadInternalQuake(name, textureflags, true, r_fullbrights.integer, pixels, image_width, image_height);
10477                         Mem_Free(f);
10478                 }
10479         }
10480         cache->skinframe = skinframe;
10481 }
10482
10483 texture_t *R_GetCurrentTexture(texture_t *t)
10484 {
10485         int i;
10486         const entity_render_t *ent = rsurface.entity;
10487         dp_model_t *model = ent->model;
10488         q3shaderinfo_layer_tcmod_t *tcmod;
10489
10490         if (t->update_lastrenderframe == r_textureframe && t->update_lastrenderentity == (void *)ent)
10491                 return t->currentframe;
10492         t->update_lastrenderframe = r_textureframe;
10493         t->update_lastrenderentity = (void *)ent;
10494
10495         if(ent && ent->entitynumber >= MAX_EDICTS && ent->entitynumber < 2 * MAX_EDICTS)
10496                 t->camera_entity = ent->entitynumber;
10497         else
10498                 t->camera_entity = 0;
10499
10500         // switch to an alternate material if this is a q1bsp animated material
10501         {
10502                 texture_t *texture = t;
10503                 int s = rsurface.ent_skinnum;
10504                 if ((unsigned int)s >= (unsigned int)model->numskins)
10505                         s = 0;
10506                 if (model->skinscenes)
10507                 {
10508                         if (model->skinscenes[s].framecount > 1)
10509                                 s = model->skinscenes[s].firstframe + (unsigned int) (r_refdef.scene.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
10510                         else
10511                                 s = model->skinscenes[s].firstframe;
10512                 }
10513                 if (s > 0)
10514                         t = t + s * model->num_surfaces;
10515                 if (t->animated)
10516                 {
10517                         // use an alternate animation if the entity's frame is not 0,
10518                         // and only if the texture has an alternate animation
10519                         if (rsurface.ent_alttextures && t->anim_total[1])
10520                                 t = t->anim_frames[1][(t->anim_total[1] >= 2) ? ((int)(r_refdef.scene.time * 5.0f) % t->anim_total[1]) : 0];
10521                         else
10522                                 t = t->anim_frames[0][(t->anim_total[0] >= 2) ? ((int)(r_refdef.scene.time * 5.0f) % t->anim_total[0]) : 0];
10523                 }
10524                 texture->currentframe = t;
10525         }
10526
10527         // update currentskinframe to be a qw skin or animation frame
10528         if (rsurface.ent_qwskin >= 0)
10529         {
10530                 i = rsurface.ent_qwskin;
10531                 if (!r_qwskincache || r_qwskincache_size != cl.maxclients)
10532                 {
10533                         r_qwskincache_size = cl.maxclients;
10534                         if (r_qwskincache)
10535                                 Mem_Free(r_qwskincache);
10536                         r_qwskincache = (r_qwskincache_t *)Mem_Alloc(r_main_mempool, sizeof(*r_qwskincache) * r_qwskincache_size);
10537                 }
10538                 if (strcmp(r_qwskincache[i].name, cl.scores[i].qw_skin))
10539                         R_LoadQWSkin(&r_qwskincache[i], cl.scores[i].qw_skin);
10540                 t->currentskinframe = r_qwskincache[i].skinframe;
10541                 if (t->currentskinframe == NULL)
10542                         t->currentskinframe = t->skinframes[(unsigned int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes];
10543         }
10544         else if (t->numskinframes >= 2)
10545                 t->currentskinframe = t->skinframes[(unsigned int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes];
10546         if (t->backgroundnumskinframes >= 2)
10547                 t->backgroundcurrentskinframe = t->backgroundskinframes[(unsigned int)(t->backgroundskinframerate * (cl.time - rsurface.ent_shadertime)) % t->backgroundnumskinframes];
10548
10549         t->currentmaterialflags = t->basematerialflags;
10550         t->currentalpha = rsurface.colormod[3];
10551         if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_novis.integer))
10552                 t->currentalpha *= r_wateralpha.value;
10553         if(t->basematerialflags & MATERIALFLAG_WATERSHADER && r_waterstate.enabled && !r_refdef.view.isoverlay)
10554                 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW; // we apply wateralpha later
10555         if(!r_waterstate.enabled || r_refdef.view.isoverlay)
10556                 t->currentmaterialflags &= ~(MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA);
10557         if (!(rsurface.ent_flags & RENDER_LIGHT))
10558                 t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
10559         else if (FAKELIGHT_ENABLED)
10560         {
10561                         // no modellight if using fakelight for the map
10562         }
10563         else if (rsurface.modeltexcoordlightmap2f == NULL && !(t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
10564         {
10565                 // pick a model lighting mode
10566                 if (VectorLength2(rsurface.modellight_diffuse) >= (1.0f / 256.0f))
10567                         t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL;
10568                 else
10569                         t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT;
10570         }
10571         if (rsurface.ent_flags & RENDER_ADDITIVE)
10572                 t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
10573         else if (t->currentalpha < 1)
10574                 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
10575         if (rsurface.ent_flags & RENDER_DOUBLESIDED)
10576                 t->currentmaterialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_NOCULLFACE;
10577         if (rsurface.ent_flags & (RENDER_NODEPTHTEST | RENDER_VIEWMODEL))
10578                 t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
10579         if (t->backgroundnumskinframes)
10580                 t->currentmaterialflags |= MATERIALFLAG_VERTEXTEXTUREBLEND;
10581         if (t->currentmaterialflags & MATERIALFLAG_BLENDED)
10582         {
10583                 if (t->currentmaterialflags & (MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER | MATERIALFLAG_CAMERA))
10584                         t->currentmaterialflags &= ~MATERIALFLAG_BLENDED;
10585         }
10586         else
10587                 t->currentmaterialflags &= ~(MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER | MATERIALFLAG_CAMERA);
10588         if ((t->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST)) == MATERIALFLAG_BLENDED && r_transparentdepthmasking.integer && !(t->basematerialflags & MATERIALFLAG_BLENDED))
10589                 t->currentmaterialflags |= MATERIALFLAG_TRANSDEPTH;
10590
10591         // there is no tcmod
10592         if (t->currentmaterialflags & MATERIALFLAG_WATERSCROLL)
10593         {
10594                 t->currenttexmatrix = r_waterscrollmatrix;
10595                 t->currentbackgroundtexmatrix = r_waterscrollmatrix;
10596         }
10597         else if (!(t->currentmaterialflags & MATERIALFLAG_CUSTOMSURFACE))
10598         {
10599                 Matrix4x4_CreateIdentity(&t->currenttexmatrix);
10600                 Matrix4x4_CreateIdentity(&t->currentbackgroundtexmatrix);
10601         }
10602
10603         for (i = 0, tcmod = t->tcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
10604                 R_tcMod_ApplyToMatrix(&t->currenttexmatrix, tcmod, t->currentmaterialflags);
10605         for (i = 0, tcmod = t->backgroundtcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
10606                 R_tcMod_ApplyToMatrix(&t->currentbackgroundtexmatrix, tcmod, t->currentmaterialflags);
10607
10608         t->colormapping = VectorLength2(rsurface.colormap_pantscolor) + VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f);
10609         if (t->currentskinframe->qpixels)
10610                 R_SkinFrame_GenerateTexturesFromQPixels(t->currentskinframe, t->colormapping);
10611         t->basetexture = (!t->colormapping && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
10612         if (!t->basetexture)
10613                 t->basetexture = r_texture_notexture;
10614         t->pantstexture = t->colormapping ? t->currentskinframe->pants : NULL;
10615         t->shirttexture = t->colormapping ? t->currentskinframe->shirt : NULL;
10616         t->nmaptexture = t->currentskinframe->nmap;
10617         if (!t->nmaptexture)
10618                 t->nmaptexture = r_texture_blanknormalmap;
10619         t->glosstexture = r_texture_black;
10620         t->glowtexture = t->currentskinframe->glow;
10621         t->fogtexture = t->currentskinframe->fog;
10622         t->reflectmasktexture = t->currentskinframe->reflect;
10623         if (t->backgroundnumskinframes)
10624         {
10625                 t->backgroundbasetexture = (!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base;
10626                 t->backgroundnmaptexture = t->backgroundcurrentskinframe->nmap;
10627                 t->backgroundglosstexture = r_texture_black;
10628                 t->backgroundglowtexture = t->backgroundcurrentskinframe->glow;
10629                 if (!t->backgroundnmaptexture)
10630                         t->backgroundnmaptexture = r_texture_blanknormalmap;
10631         }
10632         else
10633         {
10634                 t->backgroundbasetexture = r_texture_white;
10635                 t->backgroundnmaptexture = r_texture_blanknormalmap;
10636                 t->backgroundglosstexture = r_texture_black;
10637                 t->backgroundglowtexture = NULL;
10638         }
10639         t->specularpower = r_shadow_glossexponent.value;
10640         // TODO: store reference values for these in the texture?
10641         t->specularscale = 0;
10642         if (r_shadow_gloss.integer > 0)
10643         {
10644                 if (t->currentskinframe->gloss || (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss))
10645                 {
10646                         if (r_shadow_glossintensity.value > 0)
10647                         {
10648                                 t->glosstexture = t->currentskinframe->gloss ? t->currentskinframe->gloss : r_texture_white;
10649                                 t->backgroundglosstexture = (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss) ? t->backgroundcurrentskinframe->gloss : r_texture_white;
10650                                 t->specularscale = r_shadow_glossintensity.value;
10651                         }
10652                 }
10653                 else if (r_shadow_gloss.integer >= 2 && r_shadow_gloss2intensity.value > 0)
10654                 {
10655                         t->glosstexture = r_texture_white;
10656                         t->backgroundglosstexture = r_texture_white;
10657                         t->specularscale = r_shadow_gloss2intensity.value;
10658                         t->specularpower = r_shadow_gloss2exponent.value;
10659                 }
10660         }
10661         t->specularscale *= t->specularscalemod;
10662         t->specularpower *= t->specularpowermod;
10663
10664         // lightmaps mode looks bad with dlights using actual texturing, so turn
10665         // off the colormap and glossmap, but leave the normalmap on as it still
10666         // accurately represents the shading involved
10667         if (gl_lightmaps.integer)
10668         {
10669                 t->basetexture = r_texture_grey128;
10670                 t->pantstexture = r_texture_black;
10671                 t->shirttexture = r_texture_black;
10672                 t->nmaptexture = r_texture_blanknormalmap;
10673                 t->glosstexture = r_texture_black;
10674                 t->glowtexture = NULL;
10675                 t->fogtexture = NULL;
10676                 t->reflectmasktexture = NULL;
10677                 t->backgroundbasetexture = NULL;
10678                 t->backgroundnmaptexture = r_texture_blanknormalmap;
10679                 t->backgroundglosstexture = r_texture_black;
10680                 t->backgroundglowtexture = NULL;
10681                 t->specularscale = 0;
10682                 t->currentmaterialflags = MATERIALFLAG_WALL | (t->currentmaterialflags & (MATERIALFLAG_NOCULLFACE | MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SHORTDEPTHRANGE));
10683         }
10684
10685         Vector4Set(t->lightmapcolor, rsurface.colormod[0], rsurface.colormod[1], rsurface.colormod[2], t->currentalpha);
10686         VectorClear(t->dlightcolor);
10687         t->currentnumlayers = 0;
10688         if (t->currentmaterialflags & MATERIALFLAG_WALL)
10689         {
10690                 int blendfunc1, blendfunc2;
10691                 qboolean depthmask;
10692                 if (t->currentmaterialflags & MATERIALFLAG_ADD)
10693                 {
10694                         blendfunc1 = GL_SRC_ALPHA;
10695                         blendfunc2 = GL_ONE;
10696                 }
10697                 else if (t->currentmaterialflags & MATERIALFLAG_ALPHA)
10698                 {
10699                         blendfunc1 = GL_SRC_ALPHA;
10700                         blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
10701                 }
10702                 else if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
10703                 {
10704                         blendfunc1 = t->customblendfunc[0];
10705                         blendfunc2 = t->customblendfunc[1];
10706                 }
10707                 else
10708                 {
10709                         blendfunc1 = GL_ONE;
10710                         blendfunc2 = GL_ZERO;
10711                 }
10712                 // don't colormod evilblend textures
10713                 if(!R_BlendFuncAllowsColormod(blendfunc1, blendfunc2))
10714                         VectorSet(t->lightmapcolor, 1, 1, 1);
10715                 depthmask = !(t->currentmaterialflags & MATERIALFLAG_BLENDED);
10716                 if (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
10717                 {
10718                         // fullbright is not affected by r_refdef.lightmapintensity
10719                         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]);
10720                         if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
10721                                 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]);
10722                         if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
10723                                 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]);
10724                 }
10725                 else
10726                 {
10727                         vec3_t ambientcolor;
10728                         float colorscale;
10729                         // set the color tint used for lights affecting this surface
10730                         VectorSet(t->dlightcolor, t->lightmapcolor[0] * t->lightmapcolor[3], t->lightmapcolor[1] * t->lightmapcolor[3], t->lightmapcolor[2] * t->lightmapcolor[3]);
10731                         colorscale = 2;
10732                         // q3bsp has no lightmap updates, so the lightstylevalue that
10733                         // would normally be baked into the lightmap must be
10734                         // applied to the color
10735                         // FIXME: r_glsl 1 rendering doesn't support overbright lightstyles with this (the default light style is not overbright)
10736                         if (model->type == mod_brushq3)
10737                                 colorscale *= r_refdef.scene.rtlightstylevalue[0];
10738                         colorscale *= r_refdef.lightmapintensity;
10739                         VectorScale(t->lightmapcolor, r_refdef.scene.ambient, ambientcolor);
10740                         VectorScale(t->lightmapcolor, colorscale, t->lightmapcolor);
10741                         // basic lit geometry
10742                         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]);
10743                         // add pants/shirt if needed
10744                         if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
10745                                 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]);
10746                         if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
10747                                 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]);
10748                         // now add ambient passes if needed
10749                         if (VectorLength2(ambientcolor) >= (1.0f/1048576.0f))
10750                         {
10751                                 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]);
10752                                 if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
10753                                         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]);
10754                                 if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
10755                                         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]);
10756                         }
10757                 }
10758                 if (t->glowtexture != NULL && !gl_lightmaps.integer)
10759                         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]);
10760                 if (r_refdef.fogenabled && !(t->currentmaterialflags & MATERIALFLAG_ADD))
10761                 {
10762                         // if this is opaque use alpha blend which will darken the earlier
10763                         // passes cheaply.
10764                         //
10765                         // if this is an alpha blended material, all the earlier passes
10766                         // were darkened by fog already, so we only need to add the fog
10767                         // color ontop through the fog mask texture
10768                         //
10769                         // if this is an additive blended material, all the earlier passes
10770                         // were darkened by fog already, and we should not add fog color
10771                         // (because the background was not darkened, there is no fog color
10772                         // that was lost behind it).
10773                         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]);
10774                 }
10775         }
10776
10777         return t->currentframe;
10778 }
10779
10780 rsurfacestate_t rsurface;
10781
10782 void R_Mesh_ResizeArrays(int newvertices)
10783 {
10784         unsigned char *base;
10785         size_t size;
10786         if (rsurface.array_size >= newvertices)
10787                 return;
10788         if (rsurface.array_base)
10789                 Mem_Free(rsurface.array_base);
10790         rsurface.array_size = (newvertices + 1023) & ~1023;
10791         size = 0;
10792         size += rsurface.array_size * sizeof(*rsurface.array_modelvertexmesh);
10793         size += rsurface.array_size * sizeof(*rsurface.array_batchvertexmesh);
10794         size += rsurface.array_size * sizeof(*rsurface.array_modelvertexposition);
10795         size += rsurface.array_size * sizeof(*rsurface.array_batchvertexposition);
10796         size += rsurface.array_size * sizeof(float[3]);
10797         size += rsurface.array_size * sizeof(float[3]);
10798         size += rsurface.array_size * sizeof(float[3]);
10799         size += rsurface.array_size * sizeof(float[3]);
10800         size += rsurface.array_size * sizeof(float[3]);
10801         size += rsurface.array_size * sizeof(float[3]);
10802         size += rsurface.array_size * sizeof(float[3]);
10803         size += rsurface.array_size * sizeof(float[3]);
10804         size += rsurface.array_size * sizeof(float[4]);
10805         size += rsurface.array_size * sizeof(float[2]);
10806         size += rsurface.array_size * sizeof(float[2]);
10807         size += rsurface.array_size * sizeof(float[4]);
10808         size += rsurface.array_size * sizeof(int[3]);
10809         size += rsurface.array_size * sizeof(unsigned short[3]);
10810         rsurface.array_base = base = (unsigned char *)Mem_Alloc(r_main_mempool, size);
10811         rsurface.array_modelvertexmesh         = (r_vertexmesh_t     *)base;base += rsurface.array_size * sizeof(*rsurface.array_modelvertexmesh);
10812         rsurface.array_batchvertexmesh         = (r_vertexmesh_t     *)base;base += rsurface.array_size * sizeof(*rsurface.array_batchvertexmesh);
10813         rsurface.array_modelvertexposition     = (r_vertexposition_t *)base;base += rsurface.array_size * sizeof(*rsurface.array_modelvertexposition);
10814         rsurface.array_batchvertexposition     = (r_vertexposition_t *)base;base += rsurface.array_size * sizeof(*rsurface.array_batchvertexposition);
10815         rsurface.array_modelvertex3f           = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10816         rsurface.array_modelsvector3f          = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10817         rsurface.array_modeltvector3f          = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10818         rsurface.array_modelnormal3f           = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10819         rsurface.array_batchvertex3f           = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10820         rsurface.array_batchsvector3f          = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10821         rsurface.array_batchtvector3f          = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10822         rsurface.array_batchnormal3f           = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10823         rsurface.array_batchlightmapcolor4f    = (float              *)base;base += rsurface.array_size * sizeof(float[4]);
10824         rsurface.array_batchtexcoordtexture2f  = (float              *)base;base += rsurface.array_size * sizeof(float[2]);
10825         rsurface.array_batchtexcoordlightmap2f = (float              *)base;base += rsurface.array_size * sizeof(float[2]);
10826         rsurface.array_passcolor4f             = (float              *)base;base += rsurface.array_size * sizeof(float[4]);
10827         rsurface.array_batchelement3i          = (int                *)base;base += rsurface.array_size * sizeof(int[3]);
10828         rsurface.array_batchelement3s          = (unsigned short     *)base;base += rsurface.array_size * sizeof(unsigned short[3]);
10829 }
10830
10831 void RSurf_ActiveWorldEntity(void)
10832 {
10833         dp_model_t *model = r_refdef.scene.worldmodel;
10834         //if (rsurface.entity == r_refdef.scene.worldentity)
10835         //      return;
10836         rsurface.entity = r_refdef.scene.worldentity;
10837         rsurface.skeleton = NULL;
10838         memset(rsurface.userwavefunc_param, 0, sizeof(rsurface.userwavefunc_param));
10839         rsurface.ent_skinnum = 0;
10840         rsurface.ent_qwskin = -1;
10841         rsurface.ent_shadertime = 0;
10842         rsurface.ent_flags = r_refdef.scene.worldentity->flags;
10843         R_Mesh_ResizeArrays(max(model->surfmesh.num_vertices, model->surfmesh.num_triangles));
10844         rsurface.matrix = identitymatrix;
10845         rsurface.inversematrix = identitymatrix;
10846         rsurface.matrixscale = 1;
10847         rsurface.inversematrixscale = 1;
10848         R_EntityMatrix(&identitymatrix);
10849         VectorCopy(r_refdef.view.origin, rsurface.localvieworigin);
10850         Vector4Copy(r_refdef.fogplane, rsurface.fogplane);
10851         rsurface.fograngerecip = r_refdef.fograngerecip;
10852         rsurface.fogheightfade = r_refdef.fogheightfade;
10853         rsurface.fogplaneviewdist = r_refdef.fogplaneviewdist;
10854         rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
10855         VectorSet(rsurface.modellight_ambient, 0, 0, 0);
10856         VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
10857         VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
10858         VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
10859         VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
10860         VectorSet(rsurface.colormod, r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale);
10861         rsurface.colormod[3] = 1;
10862         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);
10863         memset(rsurface.frameblend, 0, sizeof(rsurface.frameblend));
10864         rsurface.frameblend[0].lerp = 1;
10865         rsurface.ent_alttextures = false;
10866         rsurface.basepolygonfactor = r_refdef.polygonfactor;
10867         rsurface.basepolygonoffset = r_refdef.polygonoffset;
10868         rsurface.modelvertex3f  = model->surfmesh.data_vertex3f;
10869         rsurface.modelvertex3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
10870         rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
10871         rsurface.modelsvector3f = model->surfmesh.data_svector3f;
10872         rsurface.modelsvector3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
10873         rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
10874         rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
10875         rsurface.modeltvector3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
10876         rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
10877         rsurface.modelnormal3f  = model->surfmesh.data_normal3f;
10878         rsurface.modelnormal3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
10879         rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
10880         rsurface.modellightmapcolor4f  = model->surfmesh.data_lightmapcolor4f;
10881         rsurface.modellightmapcolor4f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
10882         rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
10883         rsurface.modeltexcoordtexture2f  = model->surfmesh.data_texcoordtexture2f;
10884         rsurface.modeltexcoordtexture2f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
10885         rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
10886         rsurface.modeltexcoordlightmap2f  = model->surfmesh.data_texcoordlightmap2f;
10887         rsurface.modeltexcoordlightmap2f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
10888         rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
10889         rsurface.modelelement3i = model->surfmesh.data_element3i;
10890         rsurface.modelelement3i_indexbuffer = model->surfmesh.data_element3i_indexbuffer;
10891         rsurface.modelelement3i_bufferoffset = model->surfmesh.data_element3i_bufferoffset;
10892         rsurface.modelelement3s = model->surfmesh.data_element3s;
10893         rsurface.modelelement3s_indexbuffer = model->surfmesh.data_element3s_indexbuffer;
10894         rsurface.modelelement3s_bufferoffset = model->surfmesh.data_element3s_bufferoffset;
10895         rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
10896         rsurface.modelnumvertices = model->surfmesh.num_vertices;
10897         rsurface.modelnumtriangles = model->surfmesh.num_triangles;
10898         rsurface.modelsurfaces = model->data_surfaces;
10899         rsurface.modelvertexmesh = model->surfmesh.vertexmesh;
10900         rsurface.modelvertexmeshbuffer = model->surfmesh.vertexmeshbuffer;
10901         rsurface.modelvertexposition = model->surfmesh.vertexposition;
10902         rsurface.modelvertexpositionbuffer = model->surfmesh.vertexpositionbuffer;
10903         rsurface.modelgeneratedvertex = false;
10904         rsurface.batchgeneratedvertex = false;
10905         rsurface.batchfirstvertex = 0;
10906         rsurface.batchnumvertices = 0;
10907         rsurface.batchfirsttriangle = 0;
10908         rsurface.batchnumtriangles = 0;
10909         rsurface.batchvertex3f  = NULL;
10910         rsurface.batchvertex3f_vertexbuffer = NULL;
10911         rsurface.batchvertex3f_bufferoffset = 0;
10912         rsurface.batchsvector3f = NULL;
10913         rsurface.batchsvector3f_vertexbuffer = NULL;
10914         rsurface.batchsvector3f_bufferoffset = 0;
10915         rsurface.batchtvector3f = NULL;
10916         rsurface.batchtvector3f_vertexbuffer = NULL;
10917         rsurface.batchtvector3f_bufferoffset = 0;
10918         rsurface.batchnormal3f  = NULL;
10919         rsurface.batchnormal3f_vertexbuffer = NULL;
10920         rsurface.batchnormal3f_bufferoffset = 0;
10921         rsurface.batchlightmapcolor4f = NULL;
10922         rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
10923         rsurface.batchlightmapcolor4f_bufferoffset = 0;
10924         rsurface.batchtexcoordtexture2f = NULL;
10925         rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
10926         rsurface.batchtexcoordtexture2f_bufferoffset = 0;
10927         rsurface.batchtexcoordlightmap2f = NULL;
10928         rsurface.batchtexcoordlightmap2f_vertexbuffer = NULL;
10929         rsurface.batchtexcoordlightmap2f_bufferoffset = 0;
10930         rsurface.batchvertexmesh = NULL;
10931         rsurface.batchvertexmeshbuffer = NULL;
10932         rsurface.batchvertexposition = NULL;
10933         rsurface.batchvertexpositionbuffer = NULL;
10934         rsurface.batchelement3i = NULL;
10935         rsurface.batchelement3i_indexbuffer = NULL;
10936         rsurface.batchelement3i_bufferoffset = 0;
10937         rsurface.batchelement3s = NULL;
10938         rsurface.batchelement3s_indexbuffer = NULL;
10939         rsurface.batchelement3s_bufferoffset = 0;
10940         rsurface.passcolor4f = NULL;
10941         rsurface.passcolor4f_vertexbuffer = NULL;
10942         rsurface.passcolor4f_bufferoffset = 0;
10943 }
10944
10945 void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents, qboolean prepass)
10946 {
10947         dp_model_t *model = ent->model;
10948         //if (rsurface.entity == ent && (!model->surfmesh.isanimated || (!wantnormals && !wanttangents)))
10949         //      return;
10950         rsurface.entity = (entity_render_t *)ent;
10951         rsurface.skeleton = ent->skeleton;
10952         memcpy(rsurface.userwavefunc_param, ent->userwavefunc_param, sizeof(rsurface.userwavefunc_param));
10953         rsurface.ent_skinnum = ent->skinnum;
10954         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;
10955         rsurface.ent_shadertime = ent->shadertime;
10956         rsurface.ent_flags = ent->flags;
10957         R_Mesh_ResizeArrays(max(model->surfmesh.num_vertices, model->surfmesh.num_triangles));
10958         rsurface.matrix = ent->matrix;
10959         rsurface.inversematrix = ent->inversematrix;
10960         rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
10961         rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
10962         R_EntityMatrix(&rsurface.matrix);
10963         Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
10964         Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
10965         rsurface.fogplaneviewdist *= rsurface.inversematrixscale;
10966         rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
10967         rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
10968         rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
10969         VectorCopy(ent->modellight_ambient, rsurface.modellight_ambient);
10970         VectorCopy(ent->modellight_diffuse, rsurface.modellight_diffuse);
10971         VectorCopy(ent->modellight_lightdir, rsurface.modellight_lightdir);
10972         VectorCopy(ent->colormap_pantscolor, rsurface.colormap_pantscolor);
10973         VectorCopy(ent->colormap_shirtcolor, rsurface.colormap_shirtcolor);
10974         VectorScale(ent->colormod, r_refdef.view.colorscale, rsurface.colormod);
10975         rsurface.colormod[3] = ent->alpha;
10976         VectorScale(ent->glowmod, r_refdef.view.colorscale * r_hdr_glowintensity.value, rsurface.glowmod);
10977         memcpy(rsurface.frameblend, ent->frameblend, sizeof(ent->frameblend));
10978         rsurface.ent_alttextures = ent->framegroupblend[0].frame != 0;
10979         rsurface.basepolygonfactor = r_refdef.polygonfactor;
10980         rsurface.basepolygonoffset = r_refdef.polygonoffset;
10981         if (ent->model->brush.submodel && !prepass)
10982         {
10983                 rsurface.basepolygonfactor += r_polygonoffset_submodel_factor.value;
10984                 rsurface.basepolygonoffset += r_polygonoffset_submodel_offset.value;
10985         }
10986         if (model->surfmesh.isanimated && model->AnimateVertices && (rsurface.frameblend[0].lerp != 1 || rsurface.frameblend[0].subframe != 0))
10987         {
10988                 if (ent->animcache_vertex3f && !r_framedata_failed)
10989                 {
10990                         rsurface.modelvertex3f = ent->animcache_vertex3f;
10991                         rsurface.modelsvector3f = wanttangents ? ent->animcache_svector3f : NULL;
10992                         rsurface.modeltvector3f = wanttangents ? ent->animcache_tvector3f : NULL;
10993                         rsurface.modelnormal3f = wantnormals ? ent->animcache_normal3f : NULL;
10994                         rsurface.modelvertexmesh = ent->animcache_vertexmesh;
10995                         rsurface.modelvertexmeshbuffer = ent->animcache_vertexmeshbuffer;
10996                         rsurface.modelvertexposition = ent->animcache_vertexposition;
10997                         rsurface.modelvertexpositionbuffer = ent->animcache_vertexpositionbuffer;
10998                 }
10999                 else if (wanttangents)
11000                 {
11001                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
11002                         rsurface.modelsvector3f = rsurface.array_modelsvector3f;
11003                         rsurface.modeltvector3f = rsurface.array_modeltvector3f;
11004                         rsurface.modelnormal3f = rsurface.array_modelnormal3f;
11005                         model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f);
11006                         rsurface.modelvertexmesh = NULL;
11007                         rsurface.modelvertexmeshbuffer = NULL;
11008                         rsurface.modelvertexposition = NULL;
11009                         rsurface.modelvertexpositionbuffer = NULL;
11010                 }
11011                 else if (wantnormals)
11012                 {
11013                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
11014                         rsurface.modelsvector3f = NULL;
11015                         rsurface.modeltvector3f = NULL;
11016                         rsurface.modelnormal3f = rsurface.array_modelnormal3f;
11017                         model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, NULL, NULL);
11018                         rsurface.modelvertexmesh = NULL;
11019                         rsurface.modelvertexmeshbuffer = NULL;
11020                         rsurface.modelvertexposition = NULL;
11021                         rsurface.modelvertexpositionbuffer = NULL;
11022                 }
11023                 else
11024                 {
11025                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
11026                         rsurface.modelsvector3f = NULL;
11027                         rsurface.modeltvector3f = NULL;
11028                         rsurface.modelnormal3f = NULL;
11029                         model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, NULL, NULL, NULL);
11030                         rsurface.modelvertexmesh = NULL;
11031                         rsurface.modelvertexmeshbuffer = NULL;
11032                         rsurface.modelvertexposition = NULL;
11033                         rsurface.modelvertexpositionbuffer = NULL;
11034                 }
11035                 rsurface.modelvertex3f_vertexbuffer = 0;
11036                 rsurface.modelvertex3f_bufferoffset = 0;
11037                 rsurface.modelsvector3f_vertexbuffer = 0;
11038                 rsurface.modelsvector3f_bufferoffset = 0;
11039                 rsurface.modeltvector3f_vertexbuffer = 0;
11040                 rsurface.modeltvector3f_bufferoffset = 0;
11041                 rsurface.modelnormal3f_vertexbuffer = 0;
11042                 rsurface.modelnormal3f_bufferoffset = 0;
11043                 rsurface.modelgeneratedvertex = true;
11044         }
11045         else
11046         {
11047                 rsurface.modelvertex3f  = model->surfmesh.data_vertex3f;
11048                 rsurface.modelvertex3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
11049                 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
11050                 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
11051                 rsurface.modelsvector3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
11052                 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
11053                 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
11054                 rsurface.modeltvector3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
11055                 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
11056                 rsurface.modelnormal3f  = model->surfmesh.data_normal3f;
11057                 rsurface.modelnormal3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
11058                 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
11059                 rsurface.modelvertexmesh = model->surfmesh.vertexmesh;
11060                 rsurface.modelvertexmeshbuffer = model->surfmesh.vertexmeshbuffer;
11061                 rsurface.modelvertexposition = model->surfmesh.vertexposition;
11062                 rsurface.modelvertexpositionbuffer = model->surfmesh.vertexpositionbuffer;
11063                 rsurface.modelgeneratedvertex = false;
11064         }
11065         rsurface.modellightmapcolor4f  = model->surfmesh.data_lightmapcolor4f;
11066         rsurface.modellightmapcolor4f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
11067         rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
11068         rsurface.modeltexcoordtexture2f  = model->surfmesh.data_texcoordtexture2f;
11069         rsurface.modeltexcoordtexture2f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
11070         rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
11071         rsurface.modeltexcoordlightmap2f  = model->surfmesh.data_texcoordlightmap2f;
11072         rsurface.modeltexcoordlightmap2f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
11073         rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
11074         rsurface.modelelement3i = model->surfmesh.data_element3i;
11075         rsurface.modelelement3i_indexbuffer = model->surfmesh.data_element3i_indexbuffer;
11076         rsurface.modelelement3i_bufferoffset = model->surfmesh.data_element3i_bufferoffset;
11077         rsurface.modelelement3s = model->surfmesh.data_element3s;
11078         rsurface.modelelement3s_indexbuffer = model->surfmesh.data_element3s_indexbuffer;
11079         rsurface.modelelement3s_bufferoffset = model->surfmesh.data_element3s_bufferoffset;
11080         rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
11081         rsurface.modelnumvertices = model->surfmesh.num_vertices;
11082         rsurface.modelnumtriangles = model->surfmesh.num_triangles;
11083         rsurface.modelsurfaces = model->data_surfaces;
11084         rsurface.batchgeneratedvertex = false;
11085         rsurface.batchfirstvertex = 0;
11086         rsurface.batchnumvertices = 0;
11087         rsurface.batchfirsttriangle = 0;
11088         rsurface.batchnumtriangles = 0;
11089         rsurface.batchvertex3f  = NULL;
11090         rsurface.batchvertex3f_vertexbuffer = NULL;
11091         rsurface.batchvertex3f_bufferoffset = 0;
11092         rsurface.batchsvector3f = NULL;
11093         rsurface.batchsvector3f_vertexbuffer = NULL;
11094         rsurface.batchsvector3f_bufferoffset = 0;
11095         rsurface.batchtvector3f = NULL;
11096         rsurface.batchtvector3f_vertexbuffer = NULL;
11097         rsurface.batchtvector3f_bufferoffset = 0;
11098         rsurface.batchnormal3f  = NULL;
11099         rsurface.batchnormal3f_vertexbuffer = NULL;
11100         rsurface.batchnormal3f_bufferoffset = 0;
11101         rsurface.batchlightmapcolor4f = NULL;
11102         rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
11103         rsurface.batchlightmapcolor4f_bufferoffset = 0;
11104         rsurface.batchtexcoordtexture2f = NULL;
11105         rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
11106         rsurface.batchtexcoordtexture2f_bufferoffset = 0;
11107         rsurface.batchtexcoordlightmap2f = NULL;
11108         rsurface.batchtexcoordlightmap2f_vertexbuffer = NULL;
11109         rsurface.batchtexcoordlightmap2f_bufferoffset = 0;
11110         rsurface.batchvertexmesh = NULL;
11111         rsurface.batchvertexmeshbuffer = NULL;
11112         rsurface.batchvertexposition = NULL;
11113         rsurface.batchvertexpositionbuffer = NULL;
11114         rsurface.batchelement3i = NULL;
11115         rsurface.batchelement3i_indexbuffer = NULL;
11116         rsurface.batchelement3i_bufferoffset = 0;
11117         rsurface.batchelement3s = NULL;
11118         rsurface.batchelement3s_indexbuffer = NULL;
11119         rsurface.batchelement3s_bufferoffset = 0;
11120         rsurface.passcolor4f = NULL;
11121         rsurface.passcolor4f_vertexbuffer = NULL;
11122         rsurface.passcolor4f_bufferoffset = 0;
11123 }
11124
11125 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)
11126 {
11127         int i;
11128
11129         rsurface.entity = r_refdef.scene.worldentity;
11130         rsurface.skeleton = NULL;
11131         rsurface.ent_skinnum = 0;
11132         rsurface.ent_qwskin = -1;
11133         rsurface.ent_shadertime = shadertime;
11134         rsurface.ent_flags = entflags;
11135         rsurface.modelnumvertices = numvertices;
11136         rsurface.modelnumtriangles = numtriangles;
11137         R_Mesh_ResizeArrays(max(rsurface.modelnumvertices, rsurface.modelnumtriangles));
11138         rsurface.matrix = *matrix;
11139         rsurface.inversematrix = *inversematrix;
11140         rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
11141         rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
11142         R_EntityMatrix(&rsurface.matrix);
11143         Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
11144         Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
11145         rsurface.fogplaneviewdist *= rsurface.inversematrixscale;
11146         rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
11147         rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
11148         rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
11149         VectorSet(rsurface.modellight_ambient, 0, 0, 0);
11150         VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
11151         VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
11152         VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
11153         VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
11154         Vector4Set(rsurface.colormod, r * r_refdef.view.colorscale, g * r_refdef.view.colorscale, b * r_refdef.view.colorscale, a);
11155         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);
11156         memset(rsurface.frameblend, 0, sizeof(rsurface.frameblend));
11157         rsurface.frameblend[0].lerp = 1;
11158         rsurface.ent_alttextures = false;
11159         rsurface.basepolygonfactor = r_refdef.polygonfactor;
11160         rsurface.basepolygonoffset = r_refdef.polygonoffset;
11161         if (wanttangents)
11162         {
11163                 rsurface.modelvertex3f = vertex3f;
11164                 rsurface.modelsvector3f = svector3f ? svector3f : rsurface.array_modelsvector3f;
11165                 rsurface.modeltvector3f = tvector3f ? tvector3f : rsurface.array_modeltvector3f;
11166                 rsurface.modelnormal3f = normal3f ? normal3f : rsurface.array_modelnormal3f;
11167         }
11168         else if (wantnormals)
11169         {
11170                 rsurface.modelvertex3f = vertex3f;
11171                 rsurface.modelsvector3f = NULL;
11172                 rsurface.modeltvector3f = NULL;
11173                 rsurface.modelnormal3f = normal3f ? normal3f : rsurface.array_modelnormal3f;
11174         }
11175         else
11176         {
11177                 rsurface.modelvertex3f = vertex3f;
11178                 rsurface.modelsvector3f = NULL;
11179                 rsurface.modeltvector3f = NULL;
11180                 rsurface.modelnormal3f = NULL;
11181         }
11182         rsurface.modelvertexmesh = NULL;
11183         rsurface.modelvertexmeshbuffer = NULL;
11184         rsurface.modelvertexposition = NULL;
11185         rsurface.modelvertexpositionbuffer = NULL;
11186         rsurface.modelvertex3f_vertexbuffer = 0;
11187         rsurface.modelvertex3f_bufferoffset = 0;
11188         rsurface.modelsvector3f_vertexbuffer = 0;
11189         rsurface.modelsvector3f_bufferoffset = 0;
11190         rsurface.modeltvector3f_vertexbuffer = 0;
11191         rsurface.modeltvector3f_bufferoffset = 0;
11192         rsurface.modelnormal3f_vertexbuffer = 0;
11193         rsurface.modelnormal3f_bufferoffset = 0;
11194         rsurface.modelgeneratedvertex = true;
11195         rsurface.modellightmapcolor4f  = color4f;
11196         rsurface.modellightmapcolor4f_vertexbuffer = 0;
11197         rsurface.modellightmapcolor4f_bufferoffset = 0;
11198         rsurface.modeltexcoordtexture2f  = texcoord2f;
11199         rsurface.modeltexcoordtexture2f_vertexbuffer = 0;
11200         rsurface.modeltexcoordtexture2f_bufferoffset = 0;
11201         rsurface.modeltexcoordlightmap2f  = NULL;
11202         rsurface.modeltexcoordlightmap2f_vertexbuffer = 0;
11203         rsurface.modeltexcoordlightmap2f_bufferoffset = 0;
11204         rsurface.modelelement3i = element3i;
11205         rsurface.modelelement3i_indexbuffer = NULL;
11206         rsurface.modelelement3i_bufferoffset = 0;
11207         rsurface.modelelement3s = element3s;
11208         rsurface.modelelement3s_indexbuffer = NULL;
11209         rsurface.modelelement3s_bufferoffset = 0;
11210         rsurface.modellightmapoffsets = NULL;
11211         rsurface.modelsurfaces = NULL;
11212         rsurface.batchgeneratedvertex = false;
11213         rsurface.batchfirstvertex = 0;
11214         rsurface.batchnumvertices = 0;
11215         rsurface.batchfirsttriangle = 0;
11216         rsurface.batchnumtriangles = 0;
11217         rsurface.batchvertex3f  = NULL;
11218         rsurface.batchvertex3f_vertexbuffer = NULL;
11219         rsurface.batchvertex3f_bufferoffset = 0;
11220         rsurface.batchsvector3f = NULL;
11221         rsurface.batchsvector3f_vertexbuffer = NULL;
11222         rsurface.batchsvector3f_bufferoffset = 0;
11223         rsurface.batchtvector3f = NULL;
11224         rsurface.batchtvector3f_vertexbuffer = NULL;
11225         rsurface.batchtvector3f_bufferoffset = 0;
11226         rsurface.batchnormal3f  = NULL;
11227         rsurface.batchnormal3f_vertexbuffer = NULL;
11228         rsurface.batchnormal3f_bufferoffset = 0;
11229         rsurface.batchlightmapcolor4f = NULL;
11230         rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
11231         rsurface.batchlightmapcolor4f_bufferoffset = 0;
11232         rsurface.batchtexcoordtexture2f = NULL;
11233         rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
11234         rsurface.batchtexcoordtexture2f_bufferoffset = 0;
11235         rsurface.batchtexcoordlightmap2f = NULL;
11236         rsurface.batchtexcoordlightmap2f_vertexbuffer = NULL;
11237         rsurface.batchtexcoordlightmap2f_bufferoffset = 0;
11238         rsurface.batchvertexmesh = NULL;
11239         rsurface.batchvertexmeshbuffer = NULL;
11240         rsurface.batchvertexposition = NULL;
11241         rsurface.batchvertexpositionbuffer = NULL;
11242         rsurface.batchelement3i = NULL;
11243         rsurface.batchelement3i_indexbuffer = NULL;
11244         rsurface.batchelement3i_bufferoffset = 0;
11245         rsurface.batchelement3s = NULL;
11246         rsurface.batchelement3s_indexbuffer = NULL;
11247         rsurface.batchelement3s_bufferoffset = 0;
11248         rsurface.passcolor4f = NULL;
11249         rsurface.passcolor4f_vertexbuffer = NULL;
11250         rsurface.passcolor4f_bufferoffset = 0;
11251
11252         if (rsurface.modelnumvertices && rsurface.modelelement3i)
11253         {
11254                 if ((wantnormals || wanttangents) && !normal3f)
11255                 {
11256                         Mod_BuildNormals(0, rsurface.modelnumvertices, rsurface.modelnumtriangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer != 0);
11257                         rsurface.modelnormal3f = rsurface.array_modelnormal3f;
11258                 }
11259                 if (wanttangents && !svector3f)
11260                 {
11261                         Mod_BuildTextureVectorsFromNormals(0, rsurface.modelnumvertices, rsurface.modelnumtriangles, rsurface.modelvertex3f, rsurface.modeltexcoordtexture2f, rsurface.modelnormal3f, rsurface.modelelement3i, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f, r_smoothnormals_areaweighting.integer != 0);
11262                         rsurface.modelsvector3f = rsurface.array_modelsvector3f;
11263                         rsurface.modeltvector3f = rsurface.array_modeltvector3f;
11264                 }
11265         }
11266
11267         // now convert arrays into vertexmesh structs
11268         for (i = 0;i < numvertices;i++)
11269         {
11270                 VectorCopy(rsurface.modelvertex3f + 3*i, rsurface.array_modelvertexposition[i].vertex3f);
11271                 VectorCopy(rsurface.modelvertex3f + 3*i, rsurface.array_modelvertexmesh[i].vertex3f);
11272                 if (rsurface.modelsvector3f)
11273                         VectorCopy(rsurface.modelsvector3f + 3*i, rsurface.array_modelvertexmesh[i].svector3f);
11274                 if (rsurface.modeltvector3f)
11275                         VectorCopy(rsurface.modeltvector3f + 3*i, rsurface.array_modelvertexmesh[i].tvector3f);
11276                 if (rsurface.modelnormal3f)
11277                         VectorCopy(rsurface.modelnormal3f + 3*i, rsurface.array_modelvertexmesh[i].normal3f);
11278                 if (rsurface.modellightmapcolor4f)
11279                         Vector4Scale(rsurface.modellightmapcolor4f + 4*i, 255.0f, rsurface.array_modelvertexmesh[i].color4ub);
11280                 if (rsurface.modeltexcoordtexture2f)
11281                         Vector2Copy(rsurface.modeltexcoordtexture2f + 2*i, rsurface.array_modelvertexmesh[i].texcoordtexture2f);
11282                 if (rsurface.modeltexcoordlightmap2f)
11283                         Vector2Copy(rsurface.modeltexcoordlightmap2f + 2*i, rsurface.array_modelvertexmesh[i].texcoordlightmap2f);
11284         }
11285 }
11286
11287 float RSurf_FogPoint(const float *v)
11288 {
11289         // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
11290         float FogPlaneViewDist = r_refdef.fogplaneviewdist;
11291         float FogPlaneVertexDist = DotProduct(r_refdef.fogplane, v) + r_refdef.fogplane[3];
11292         float FogHeightFade = r_refdef.fogheightfade;
11293         float fogfrac;
11294         unsigned int fogmasktableindex;
11295         if (r_refdef.fogplaneviewabove)
11296                 fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
11297         else
11298                 fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
11299         fogmasktableindex = (unsigned int)(VectorDistance(r_refdef.view.origin, v) * fogfrac * r_refdef.fogmasktabledistmultiplier);
11300         return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
11301 }
11302
11303 float RSurf_FogVertex(const float *v)
11304 {
11305         // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
11306         float FogPlaneViewDist = rsurface.fogplaneviewdist;
11307         float FogPlaneVertexDist = DotProduct(rsurface.fogplane, v) + rsurface.fogplane[3];
11308         float FogHeightFade = rsurface.fogheightfade;
11309         float fogfrac;
11310         unsigned int fogmasktableindex;
11311         if (r_refdef.fogplaneviewabove)
11312                 fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
11313         else
11314                 fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
11315         fogmasktableindex = (unsigned int)(VectorDistance(rsurface.localvieworigin, v) * fogfrac * rsurface.fogmasktabledistmultiplier);
11316         return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
11317 }
11318
11319 void RSurf_RenumberElements(const int *inelement3i, int *outelement3i, int numelements, int adjust)
11320 {
11321         int i;
11322         for (i = 0;i < numelements;i++)
11323                 outelement3i[i] = inelement3i[i] + adjust;
11324 }
11325
11326 static const int quadedges[6][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}};
11327 extern cvar_t gl_vbo;
11328 void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const msurface_t **texturesurfacelist)
11329 {
11330         int deformindex;
11331         int firsttriangle;
11332         int numtriangles;
11333         int firstvertex;
11334         int endvertex;
11335         int numvertices;
11336         int surfacefirsttriangle;
11337         int surfacenumtriangles;
11338         int surfacefirstvertex;
11339         int surfaceendvertex;
11340         int surfacenumvertices;
11341         int needsupdate;
11342         int i, j;
11343         qboolean gaps;
11344         qboolean dynamicvertex;
11345         float amplitude;
11346         float animpos;
11347         float scale;
11348         float center[3], forward[3], right[3], up[3], v[3], newforward[3], newright[3], newup[3];
11349         float waveparms[4];
11350         q3shaderinfo_deform_t *deform;
11351         const msurface_t *surface, *firstsurface;
11352         r_vertexposition_t *vertexposition;
11353         r_vertexmesh_t *vertexmesh;
11354         if (!texturenumsurfaces)
11355                 return;
11356         // find vertex range of this surface batch
11357         gaps = false;
11358         firstsurface = texturesurfacelist[0];
11359         firsttriangle = firstsurface->num_firsttriangle;
11360         numtriangles = 0;
11361         firstvertex = endvertex = firstsurface->num_firstvertex;
11362         for (i = 0;i < texturenumsurfaces;i++)
11363         {
11364                 surface = texturesurfacelist[i];
11365                 if (surface != firstsurface + i)
11366                         gaps = true;
11367                 surfacefirstvertex = surface->num_firstvertex;
11368                 surfaceendvertex = surfacefirstvertex + surface->num_vertices;
11369                 surfacenumtriangles = surface->num_triangles;
11370                 if (firstvertex > surfacefirstvertex)
11371                         firstvertex = surfacefirstvertex;
11372                 if (endvertex < surfaceendvertex)
11373                         endvertex = surfaceendvertex;
11374                 numtriangles += surfacenumtriangles;
11375         }
11376         if (!numtriangles)
11377                 return;
11378
11379         // we now know the vertex range used, and if there are any gaps in it
11380         rsurface.batchfirstvertex = firstvertex;
11381         rsurface.batchnumvertices = endvertex - firstvertex;
11382         rsurface.batchfirsttriangle = firsttriangle;
11383         rsurface.batchnumtriangles = numtriangles;
11384
11385         // this variable holds flags for which properties have been updated that
11386         // may require regenerating vertexmesh or vertexposition arrays...
11387         needsupdate = 0;
11388
11389         // check if any dynamic vertex processing must occur
11390         dynamicvertex = false;
11391
11392         if ((batchneed & (BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_ARRAY_VERTEXCOLOR)) && texturesurfacelist[0]->lightmapinfo)
11393                 needsupdate |= BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_NOGAPS;
11394         for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform;deformindex++, deform++)
11395         {
11396                 switch (deform->deform)
11397                 {
11398                 default:
11399                 case Q3DEFORM_PROJECTIONSHADOW:
11400                 case Q3DEFORM_TEXT0:
11401                 case Q3DEFORM_TEXT1:
11402                 case Q3DEFORM_TEXT2:
11403                 case Q3DEFORM_TEXT3:
11404                 case Q3DEFORM_TEXT4:
11405                 case Q3DEFORM_TEXT5:
11406                 case Q3DEFORM_TEXT6:
11407                 case Q3DEFORM_TEXT7:
11408                 case Q3DEFORM_NONE:
11409                         break;
11410                 case Q3DEFORM_AUTOSPRITE:
11411                         dynamicvertex = true;
11412                         batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS;
11413                         needsupdate |= BATCHNEED_VERTEXPOSITION | BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
11414                         break;
11415                 case Q3DEFORM_AUTOSPRITE2:
11416                         dynamicvertex = true;
11417                         batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS;
11418                         needsupdate |= BATCHNEED_VERTEXPOSITION | BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
11419                         break;
11420                 case Q3DEFORM_NORMAL:
11421                         dynamicvertex = true;
11422                         batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS;
11423                         needsupdate |= BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
11424                         break;
11425                 case Q3DEFORM_WAVE:
11426                         if(!R_TestQ3WaveFunc(deform->wavefunc, deform->waveparms))
11427                                 break; // if wavefunc is a nop, ignore this transform
11428                         dynamicvertex = true;
11429                         batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS;
11430                         needsupdate |= BATCHNEED_VERTEXPOSITION | BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
11431                         break;
11432                 case Q3DEFORM_BULGE:
11433                         dynamicvertex = true;
11434                         batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS;
11435                         needsupdate |= BATCHNEED_VERTEXPOSITION | BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
11436                         break;
11437                 case Q3DEFORM_MOVE:
11438                         if(!R_TestQ3WaveFunc(deform->wavefunc, deform->waveparms))
11439                                 break; // if wavefunc is a nop, ignore this transform
11440                         dynamicvertex = true;
11441                         batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS;
11442                         needsupdate |= BATCHNEED_VERTEXPOSITION | BATCHNEED_VERTEXMESH_VERTEX;
11443                         break;
11444                 }
11445         }
11446         switch(rsurface.texture->tcgen.tcgen)
11447         {
11448         default:
11449         case Q3TCGEN_TEXTURE:
11450                 break;
11451         case Q3TCGEN_LIGHTMAP:
11452                 dynamicvertex = true;
11453                 batchneed |= BATCHNEED_ARRAY_LIGHTMAP | BATCHNEED_NOGAPS;
11454                 needsupdate |= BATCHNEED_VERTEXMESH_LIGHTMAP;
11455                 break;
11456         case Q3TCGEN_VECTOR:
11457                 dynamicvertex = true;
11458                 batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS;
11459                 needsupdate |= BATCHNEED_VERTEXMESH_TEXCOORD;
11460                 break;
11461         case Q3TCGEN_ENVIRONMENT:
11462                 dynamicvertex = true;
11463                 batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_NOGAPS;
11464                 needsupdate |= BATCHNEED_VERTEXMESH_TEXCOORD;
11465                 break;
11466         }
11467         if (rsurface.texture->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
11468         {
11469                 dynamicvertex = true;
11470                 batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS;
11471                 needsupdate |= BATCHNEED_VERTEXMESH_TEXCOORD;
11472         }
11473
11474         if (!rsurface.modelvertexmesh && (batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP)))
11475         {
11476                 dynamicvertex = true;
11477                 batchneed |= BATCHNEED_NOGAPS;
11478                 needsupdate |= (batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP));
11479         }
11480
11481         if (needsupdate & batchneed & BATCHNEED_VERTEXPOSITION)
11482         {
11483                 dynamicvertex = true;
11484                 batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS;
11485                 needsupdate |= (batchneed & BATCHNEED_VERTEXPOSITION);
11486         }
11487
11488         if (dynamicvertex || gaps || rsurface.batchfirstvertex)
11489         {
11490                 // when copying, we need to consider the regeneration of vertexmesh, any dependencies it may have must be set...
11491                 if (batchneed & BATCHNEED_VERTEXMESH_VERTEX)      batchneed |= BATCHNEED_ARRAY_VERTEX;
11492                 if (batchneed & BATCHNEED_VERTEXMESH_NORMAL)      batchneed |= BATCHNEED_ARRAY_NORMAL;
11493                 if (batchneed & BATCHNEED_VERTEXMESH_VECTOR)      batchneed |= BATCHNEED_ARRAY_VECTOR;
11494                 if (batchneed & BATCHNEED_VERTEXMESH_VERTEXCOLOR) batchneed |= BATCHNEED_ARRAY_VERTEXCOLOR;
11495                 if (batchneed & BATCHNEED_VERTEXMESH_TEXCOORD)    batchneed |= BATCHNEED_ARRAY_TEXCOORD;
11496                 if (batchneed & BATCHNEED_VERTEXMESH_LIGHTMAP)    batchneed |= BATCHNEED_ARRAY_LIGHTMAP;
11497         }
11498
11499         // when the model data has no vertex buffer (dynamic mesh), we need to
11500         // eliminate gaps
11501         if (!rsurface.modelvertexmeshbuffer)
11502                 batchneed |= BATCHNEED_NOGAPS;
11503
11504         // if needsupdate, we have to do a dynamic vertex batch for sure
11505         if (needsupdate & batchneed)
11506                 dynamicvertex = true;
11507
11508         // see if we need to build vertexmesh from arrays
11509         if (!rsurface.modelvertexmesh && (batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP)))
11510                 dynamicvertex = true;
11511
11512         // see if we need to build vertexposition from arrays
11513         if (!rsurface.modelvertexposition && (batchneed & BATCHNEED_VERTEXPOSITION))
11514                 dynamicvertex = true;
11515
11516         // if gaps are unacceptable, and there are gaps, it's a dynamic batch...
11517         if ((batchneed & BATCHNEED_NOGAPS) && (gaps || firstvertex))
11518                 dynamicvertex = true;
11519
11520         // if there is a chance of animated vertex colors, it's a dynamic batch
11521         if ((batchneed & (BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_ARRAY_VERTEXCOLOR)) && texturesurfacelist[0]->lightmapinfo)
11522                 dynamicvertex = true;
11523
11524         rsurface.batchvertex3f = rsurface.modelvertex3f;
11525         rsurface.batchvertex3f_vertexbuffer = rsurface.modelvertex3f_vertexbuffer;
11526         rsurface.batchvertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
11527         rsurface.batchsvector3f = rsurface.modelsvector3f;
11528         rsurface.batchsvector3f_vertexbuffer = rsurface.modelsvector3f_vertexbuffer;
11529         rsurface.batchsvector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
11530         rsurface.batchtvector3f = rsurface.modeltvector3f;
11531         rsurface.batchtvector3f_vertexbuffer = rsurface.modeltvector3f_vertexbuffer;
11532         rsurface.batchtvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
11533         rsurface.batchnormal3f = rsurface.modelnormal3f;
11534         rsurface.batchnormal3f_vertexbuffer = rsurface.modelnormal3f_vertexbuffer;
11535         rsurface.batchnormal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
11536         rsurface.batchlightmapcolor4f = rsurface.modellightmapcolor4f;
11537         rsurface.batchlightmapcolor4f_vertexbuffer  = rsurface.modellightmapcolor4f_vertexbuffer;
11538         rsurface.batchlightmapcolor4f_bufferoffset  = rsurface.modellightmapcolor4f_bufferoffset;
11539         rsurface.batchtexcoordtexture2f = rsurface.modeltexcoordtexture2f;
11540         rsurface.batchtexcoordtexture2f_vertexbuffer  = rsurface.modeltexcoordtexture2f_vertexbuffer;
11541         rsurface.batchtexcoordtexture2f_bufferoffset  = rsurface.modeltexcoordtexture2f_bufferoffset;
11542         rsurface.batchtexcoordlightmap2f = rsurface.modeltexcoordlightmap2f;
11543         rsurface.batchtexcoordlightmap2f_vertexbuffer = rsurface.modeltexcoordlightmap2f_vertexbuffer;
11544         rsurface.batchtexcoordlightmap2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
11545         rsurface.batchvertexposition = rsurface.modelvertexposition;
11546         rsurface.batchvertexpositionbuffer = rsurface.modelvertexpositionbuffer;
11547         rsurface.batchvertexmesh = rsurface.modelvertexmesh;
11548         rsurface.batchvertexmeshbuffer = rsurface.modelvertexmeshbuffer;
11549         rsurface.batchelement3i = rsurface.modelelement3i;
11550         rsurface.batchelement3i_indexbuffer = rsurface.modelelement3i_indexbuffer;
11551         rsurface.batchelement3i_bufferoffset = rsurface.modelelement3i_bufferoffset;
11552         rsurface.batchelement3s = rsurface.modelelement3s;
11553         rsurface.batchelement3s_indexbuffer = rsurface.modelelement3s_indexbuffer;
11554         rsurface.batchelement3s_bufferoffset = rsurface.modelelement3s_bufferoffset;
11555
11556         // if any dynamic vertex processing has to occur in software, we copy the
11557         // entire surface list together before processing to rebase the vertices
11558         // to start at 0 (otherwise we waste a lot of room in a vertex buffer).
11559         //
11560         // if any gaps exist and we do not have a static vertex buffer, we have to
11561         // copy the surface list together to avoid wasting upload bandwidth on the
11562         // vertices in the gaps.
11563         //
11564         // if gaps exist and we have a static vertex buffer, we still have to
11565         // combine the index buffer ranges into one dynamic index buffer.
11566         //
11567         // in all cases we end up with data that can be drawn in one call.
11568
11569         if (!dynamicvertex)
11570         {
11571                 // static vertex data, just set pointers...
11572                 rsurface.batchgeneratedvertex = false;
11573                 // if there are gaps, we want to build a combined index buffer,
11574                 // otherwise use the original static buffer with an appropriate offset
11575                 if (gaps)
11576                 {
11577                         firsttriangle = 0;
11578                         numtriangles = 0;
11579                         for (i = 0;i < texturenumsurfaces;i++)
11580                         {
11581                                 surfacefirsttriangle = texturesurfacelist[i]->num_firsttriangle;
11582                                 surfacenumtriangles = texturesurfacelist[i]->num_triangles;
11583                                 memcpy(rsurface.array_batchelement3i + 3*numtriangles, rsurface.modelelement3i + 3*surfacefirsttriangle, surfacenumtriangles*sizeof(int[3]));
11584                                 numtriangles += surfacenumtriangles;
11585                         }
11586                         rsurface.batchelement3i = rsurface.array_batchelement3i;
11587                         rsurface.batchelement3i_indexbuffer = NULL;
11588                         rsurface.batchelement3i_bufferoffset = 0;
11589                         rsurface.batchelement3s = NULL;
11590                         rsurface.batchelement3s_indexbuffer = NULL;
11591                         rsurface.batchelement3s_bufferoffset = 0;
11592                         if (endvertex <= 65536)
11593                         {
11594                                 rsurface.batchelement3s = rsurface.array_batchelement3s;
11595                                 for (i = 0;i < numtriangles*3;i++)
11596                                         rsurface.array_batchelement3s[i] = rsurface.array_batchelement3i[i];
11597                         }
11598                         rsurface.batchfirsttriangle = firsttriangle;
11599                         rsurface.batchnumtriangles = numtriangles;
11600                 }
11601                 return;
11602         }
11603
11604         // something needs software processing, do it for real...
11605         // we only directly handle interleaved array data in this case...
11606         rsurface.batchgeneratedvertex = true;
11607
11608         // now copy the vertex data into a combined array and make an index array
11609         // (this is what Quake3 does all the time)
11610         //if (gaps || rsurface.batchfirstvertex)
11611         {
11612                 rsurface.batchvertexposition = NULL;
11613                 rsurface.batchvertexpositionbuffer = NULL;
11614                 rsurface.batchvertexmesh = NULL;
11615                 rsurface.batchvertexmeshbuffer = NULL;
11616                 rsurface.batchvertex3f = NULL;
11617                 rsurface.batchvertex3f_vertexbuffer = NULL;
11618                 rsurface.batchvertex3f_bufferoffset = 0;
11619                 rsurface.batchsvector3f = NULL;
11620                 rsurface.batchsvector3f_vertexbuffer = NULL;
11621                 rsurface.batchsvector3f_bufferoffset = 0;
11622                 rsurface.batchtvector3f = NULL;
11623                 rsurface.batchtvector3f_vertexbuffer = NULL;
11624                 rsurface.batchtvector3f_bufferoffset = 0;
11625                 rsurface.batchnormal3f = NULL;
11626                 rsurface.batchnormal3f_vertexbuffer = NULL;
11627                 rsurface.batchnormal3f_bufferoffset = 0;
11628                 rsurface.batchlightmapcolor4f = NULL;
11629                 rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
11630                 rsurface.batchlightmapcolor4f_bufferoffset = 0;
11631                 rsurface.batchtexcoordtexture2f = NULL;
11632                 rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
11633                 rsurface.batchtexcoordtexture2f_bufferoffset = 0;
11634                 rsurface.batchtexcoordlightmap2f = NULL;
11635                 rsurface.batchtexcoordlightmap2f_vertexbuffer = NULL;
11636                 rsurface.batchtexcoordlightmap2f_bufferoffset = 0;
11637                 rsurface.batchelement3i = rsurface.array_batchelement3i;
11638                 rsurface.batchelement3i_indexbuffer = NULL;
11639                 rsurface.batchelement3i_bufferoffset = 0;
11640                 rsurface.batchelement3s = NULL;
11641                 rsurface.batchelement3s_indexbuffer = NULL;
11642                 rsurface.batchelement3s_bufferoffset = 0;
11643                 // we'll only be setting up certain arrays as needed
11644                 if (batchneed & BATCHNEED_VERTEXPOSITION)
11645                         rsurface.batchvertexposition = rsurface.array_batchvertexposition;
11646                 if (batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP))
11647                         rsurface.batchvertexmesh = rsurface.array_batchvertexmesh;
11648                 if (batchneed & BATCHNEED_ARRAY_VERTEX)
11649                         rsurface.batchvertex3f = rsurface.array_batchvertex3f;
11650                 if (batchneed & BATCHNEED_ARRAY_NORMAL)
11651                         rsurface.batchnormal3f = rsurface.array_batchnormal3f;
11652                 if (batchneed & BATCHNEED_ARRAY_VECTOR)
11653                 {
11654                         rsurface.batchsvector3f = rsurface.array_batchsvector3f;
11655                         rsurface.batchtvector3f = rsurface.array_batchtvector3f;
11656                 }
11657                 if (batchneed & BATCHNEED_ARRAY_VERTEXCOLOR)
11658                         rsurface.batchlightmapcolor4f = rsurface.array_batchlightmapcolor4f;
11659                 if (batchneed & BATCHNEED_ARRAY_TEXCOORD)
11660                         rsurface.batchtexcoordtexture2f = rsurface.array_batchtexcoordtexture2f;
11661                 if (batchneed & BATCHNEED_ARRAY_LIGHTMAP)
11662                         rsurface.batchtexcoordlightmap2f = rsurface.array_batchtexcoordlightmap2f;
11663                 numvertices = 0;
11664                 numtriangles = 0;
11665                 for (i = 0;i < texturenumsurfaces;i++)
11666                 {
11667                         surfacefirstvertex = texturesurfacelist[i]->num_firstvertex;
11668                         surfacenumvertices = texturesurfacelist[i]->num_vertices;
11669                         surfacefirsttriangle = texturesurfacelist[i]->num_firsttriangle;
11670                         surfacenumtriangles = texturesurfacelist[i]->num_triangles;
11671                         // copy only the data requested
11672                         if ((batchneed & BATCHNEED_VERTEXPOSITION) && rsurface.modelvertexposition)
11673                                 memcpy(rsurface.array_batchvertexposition + numvertices, rsurface.modelvertexposition + surfacefirstvertex, surfacenumvertices * sizeof(rsurface.batchvertexposition[0]));
11674                         if ((batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP)) && rsurface.modelvertexmesh)
11675                                 memcpy(rsurface.array_batchvertexmesh + numvertices, rsurface.modelvertexmesh + surfacefirstvertex, surfacenumvertices * sizeof(rsurface.batchvertexmesh[0]));
11676                         if (batchneed & (BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | BATCHNEED_ARRAY_VERTEXCOLOR | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_ARRAY_LIGHTMAP))
11677                         {
11678                                 if (batchneed & BATCHNEED_ARRAY_VERTEX)
11679                                         memcpy(rsurface.array_batchvertex3f + 3*numvertices, rsurface.modelvertex3f + 3*surfacefirstvertex, surfacenumvertices * sizeof(float[3]));
11680                                 if ((batchneed & BATCHNEED_ARRAY_NORMAL) && rsurface.modelnormal3f)
11681                                         memcpy(rsurface.array_batchnormal3f + 3*numvertices, rsurface.modelnormal3f + 3*surfacefirstvertex, surfacenumvertices * sizeof(float[3]));
11682                                 if ((batchneed & BATCHNEED_ARRAY_VECTOR) && rsurface.modelsvector3f)
11683                                 {
11684                                         memcpy(rsurface.array_batchsvector3f + 3*numvertices, rsurface.modelsvector3f + 3*surfacefirstvertex, surfacenumvertices * sizeof(float[3]));
11685                                         memcpy(rsurface.array_batchtvector3f + 3*numvertices, rsurface.modeltvector3f + 3*surfacefirstvertex, surfacenumvertices * sizeof(float[3]));
11686                                 }
11687                                 if ((batchneed & BATCHNEED_ARRAY_VERTEXCOLOR) && rsurface.modellightmapcolor4f)
11688                                         memcpy(rsurface.array_batchlightmapcolor4f + 4*numvertices, rsurface.modellightmapcolor4f + 4*surfacefirstvertex, surfacenumvertices * sizeof(float[4]));
11689                                 if ((batchneed & BATCHNEED_ARRAY_TEXCOORD) && rsurface.modeltexcoordtexture2f)
11690                                         memcpy(rsurface.array_batchtexcoordtexture2f + 2*numvertices, rsurface.modeltexcoordtexture2f + 2*surfacefirstvertex, surfacenumvertices * sizeof(float[2]));
11691                                 if ((batchneed & BATCHNEED_ARRAY_LIGHTMAP) && rsurface.modeltexcoordlightmap2f)
11692                                         memcpy(rsurface.array_batchtexcoordlightmap2f + 2*numvertices, rsurface.modeltexcoordlightmap2f + 2*surfacefirstvertex, surfacenumvertices * sizeof(float[2]));
11693                         }
11694                         RSurf_RenumberElements(rsurface.modelelement3i + 3*surfacefirsttriangle, rsurface.array_batchelement3i + 3*numtriangles, 3*surfacenumtriangles, numvertices - surfacefirstvertex);
11695                         numvertices += surfacenumvertices;
11696                         numtriangles += surfacenumtriangles;
11697                 }
11698
11699                 // generate a 16bit index array as well if possible
11700                 // (in general, dynamic batches fit)
11701                 if (numvertices <= 65536)
11702                 {
11703                         rsurface.batchelement3s = rsurface.array_batchelement3s;
11704                         for (i = 0;i < numtriangles*3;i++)
11705                                 rsurface.array_batchelement3s[i] = rsurface.array_batchelement3i[i];
11706                 }
11707
11708                 // since we've copied everything, the batch now starts at 0
11709                 rsurface.batchfirstvertex = 0;
11710                 rsurface.batchnumvertices = numvertices;
11711                 rsurface.batchfirsttriangle = 0;
11712                 rsurface.batchnumtriangles = numtriangles;
11713         }
11714
11715         // q1bsp surfaces rendered in vertex color mode have to have colors
11716         // calculated based on lightstyles
11717         if ((batchneed & (BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_ARRAY_VERTEXCOLOR)) && texturesurfacelist[0]->lightmapinfo)
11718         {
11719                 // generate color arrays for the surfaces in this list
11720                 int c[4];
11721                 int scale;
11722                 int size3;
11723                 const int *offsets;
11724                 const unsigned char *lm;
11725                 numvertices = 0;
11726                 rsurface.batchlightmapcolor4f = rsurface.array_batchlightmapcolor4f;
11727                 rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
11728                 rsurface.batchlightmapcolor4f_bufferoffset = 0;
11729                 for (i = 0;i < texturenumsurfaces;i++)
11730                 {
11731                         surface = texturesurfacelist[i];
11732                         offsets = rsurface.modellightmapoffsets + surface->num_firstvertex;
11733                         surfacenumvertices = surface->num_vertices;
11734                         if (surface->lightmapinfo->samples)
11735                         {
11736                                 for (j = 0;j < surfacenumvertices;j++)
11737                                 {
11738                                         lm = surface->lightmapinfo->samples + offsets[j];
11739                                         scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[0]];
11740                                         VectorScale(lm, scale, c);
11741                                         if (surface->lightmapinfo->styles[1] != 255)
11742                                         {
11743                                                 size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
11744                                                 lm += size3;
11745                                                 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[1]];
11746                                                 VectorMA(c, scale, lm, c);
11747                                                 if (surface->lightmapinfo->styles[2] != 255)
11748                                                 {
11749                                                         lm += size3;
11750                                                         scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[2]];
11751                                                         VectorMA(c, scale, lm, c);
11752                                                         if (surface->lightmapinfo->styles[3] != 255)
11753                                                         {
11754                                                                 lm += size3;
11755                                                                 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[3]];
11756                                                                 VectorMA(c, scale, lm, c);
11757                                                         }
11758                                                 }
11759                                         }
11760                                         c[0] >>= 15;
11761                                         c[1] >>= 15;
11762                                         c[2] >>= 15;
11763                                         Vector4Set(rsurface.array_batchlightmapcolor4f + 4*numvertices, min(c[0], 255) * (1.0f / 255.0f), min(c[1], 255) * (1.0f / 255.0f), min(c[2], 255) * (1.0f / 255.0f), 1);
11764                                         numvertices++;
11765                                 }
11766                         }
11767                         else
11768                         {
11769                                 for (j = 0;j < surfacenumvertices;j++)
11770                                 {
11771                                         Vector4Set(rsurface.array_batchlightmapcolor4f + 4*numvertices, 0, 0, 0, 1);
11772                                         numvertices++;
11773                                 }
11774                         }
11775                 }
11776         }
11777
11778         // if vertices are deformed (sprite flares and things in maps, possibly
11779         // water waves, bulges and other deformations), modify the copied vertices
11780         // in place
11781         for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform;deformindex++, deform++)
11782         {
11783                 switch (deform->deform)
11784                 {
11785                 default:
11786                 case Q3DEFORM_PROJECTIONSHADOW:
11787                 case Q3DEFORM_TEXT0:
11788                 case Q3DEFORM_TEXT1:
11789                 case Q3DEFORM_TEXT2:
11790                 case Q3DEFORM_TEXT3:
11791                 case Q3DEFORM_TEXT4:
11792                 case Q3DEFORM_TEXT5:
11793                 case Q3DEFORM_TEXT6:
11794                 case Q3DEFORM_TEXT7:
11795                 case Q3DEFORM_NONE:
11796                         break;
11797                 case Q3DEFORM_AUTOSPRITE:
11798                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
11799                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
11800                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
11801                         VectorNormalize(newforward);
11802                         VectorNormalize(newright);
11803                         VectorNormalize(newup);
11804                         // a single autosprite surface can contain multiple sprites...
11805                         for (j = 0;j < rsurface.batchnumvertices - 3;j += 4)
11806                         {
11807                                 VectorClear(center);
11808                                 for (i = 0;i < 4;i++)
11809                                         VectorAdd(center, rsurface.batchvertex3f + 3*(j+i), center);
11810                                 VectorScale(center, 0.25f, center);
11811                                 VectorCopy(rsurface.batchnormal3f + 3*j, forward);
11812                                 VectorCopy(rsurface.batchsvector3f + 3*j, right);
11813                                 VectorCopy(rsurface.batchtvector3f + 3*j, up);
11814                                 for (i = 0;i < 4;i++)
11815                                 {
11816                                         VectorSubtract(rsurface.batchvertex3f + 3*(j+i), center, v);
11817                                         VectorMAMAMAM(1, center, DotProduct(forward, v), newforward, DotProduct(right, v), newright, DotProduct(up, v), newup, rsurface.array_batchvertex3f + 3*(j+i));
11818                                 }
11819                         }
11820                         // if we get here, BATCHNEED_ARRAY_NORMAL and BATCHNEED_ARRAY_VECTOR are in batchneed, so no need to check
11821                         Mod_BuildNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchnormal3f, true);
11822                         Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.array_batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchsvector3f, rsurface.array_batchtvector3f, true);
11823                         rsurface.batchvertex3f = rsurface.array_batchvertex3f;
11824                         rsurface.batchvertex3f_vertexbuffer = NULL;
11825                         rsurface.batchvertex3f_bufferoffset = 0;
11826                         rsurface.batchsvector3f = rsurface.array_batchsvector3f;
11827                         rsurface.batchsvector3f_vertexbuffer = NULL;
11828                         rsurface.batchsvector3f_bufferoffset = 0;
11829                         rsurface.batchtvector3f = rsurface.array_batchtvector3f;
11830                         rsurface.batchtvector3f_vertexbuffer = NULL;
11831                         rsurface.batchtvector3f_bufferoffset = 0;
11832                         rsurface.batchnormal3f = rsurface.array_batchnormal3f;
11833                         rsurface.batchnormal3f_vertexbuffer = NULL;
11834                         rsurface.batchnormal3f_bufferoffset = 0;
11835                         break;
11836                 case Q3DEFORM_AUTOSPRITE2:
11837                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
11838                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
11839                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
11840                         VectorNormalize(newforward);
11841                         VectorNormalize(newright);
11842                         VectorNormalize(newup);
11843                         {
11844                                 const float *v1, *v2;
11845                                 vec3_t start, end;
11846                                 float f, l;
11847                                 struct
11848                                 {
11849                                         float length2;
11850                                         const float *v1;
11851                                         const float *v2;
11852                                 }
11853                                 shortest[2];
11854                                 memset(shortest, 0, sizeof(shortest));
11855                                 // a single autosprite surface can contain multiple sprites...
11856                                 for (j = 0;j < rsurface.batchnumvertices - 3;j += 4)
11857                                 {
11858                                         VectorClear(center);
11859                                         for (i = 0;i < 4;i++)
11860                                                 VectorAdd(center, rsurface.batchvertex3f + 3*(j+i), center);
11861                                         VectorScale(center, 0.25f, center);
11862                                         // find the two shortest edges, then use them to define the
11863                                         // axis vectors for rotating around the central axis
11864                                         for (i = 0;i < 6;i++)
11865                                         {
11866                                                 v1 = rsurface.batchvertex3f + 3*(j+quadedges[i][0]);
11867                                                 v2 = rsurface.batchvertex3f + 3*(j+quadedges[i][1]);
11868                                                 l = VectorDistance2(v1, v2);
11869                                                 // this length bias tries to make sense of square polygons, assuming they are meant to be upright
11870                                                 if (v1[2] != v2[2])
11871                                                         l += (1.0f / 1024.0f);
11872                                                 if (shortest[0].length2 > l || i == 0)
11873                                                 {
11874                                                         shortest[1] = shortest[0];
11875                                                         shortest[0].length2 = l;
11876                                                         shortest[0].v1 = v1;
11877                                                         shortest[0].v2 = v2;
11878                                                 }
11879                                                 else if (shortest[1].length2 > l || i == 1)
11880                                                 {
11881                                                         shortest[1].length2 = l;
11882                                                         shortest[1].v1 = v1;
11883                                                         shortest[1].v2 = v2;
11884                                                 }
11885                                         }
11886                                         VectorLerp(shortest[0].v1, 0.5f, shortest[0].v2, start);
11887                                         VectorLerp(shortest[1].v1, 0.5f, shortest[1].v2, end);
11888                                         // this calculates the right vector from the shortest edge
11889                                         // and the up vector from the edge midpoints
11890                                         VectorSubtract(shortest[0].v1, shortest[0].v2, right);
11891                                         VectorNormalize(right);
11892                                         VectorSubtract(end, start, up);
11893                                         VectorNormalize(up);
11894                                         // calculate a forward vector to use instead of the original plane normal (this is how we get a new right vector)
11895                                         VectorSubtract(rsurface.localvieworigin, center, forward);
11896                                         //Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, forward);
11897                                         VectorNegate(forward, forward);
11898                                         VectorReflect(forward, 0, up, forward);
11899                                         VectorNormalize(forward);
11900                                         CrossProduct(up, forward, newright);
11901                                         VectorNormalize(newright);
11902                                         // rotate the quad around the up axis vector, this is made
11903                                         // especially easy by the fact we know the quad is flat,
11904                                         // so we only have to subtract the center position and
11905                                         // measure distance along the right vector, and then
11906                                         // multiply that by the newright vector and add back the
11907                                         // center position
11908                                         // we also need to subtract the old position to undo the
11909                                         // displacement from the center, which we do with a
11910                                         // DotProduct, the subtraction/addition of center is also
11911                                         // optimized into DotProducts here
11912                                         l = DotProduct(right, center);
11913                                         for (i = 0;i < 4;i++)
11914                                         {
11915                                                 v1 = rsurface.batchvertex3f + 3*(j+i);
11916                                                 f = DotProduct(right, v1) - l;
11917                                                 VectorMAMAM(1, v1, -f, right, f, newright, rsurface.array_batchvertex3f + 3*(j+i));
11918                                         }
11919                                 }
11920                         }
11921                         rsurface.batchvertex3f = rsurface.array_batchvertex3f;
11922                         rsurface.batchvertex3f_vertexbuffer = NULL;
11923                         rsurface.batchvertex3f_bufferoffset = 0;
11924                         if(batchneed & (BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR)) // otherwise these can stay NULL
11925                         {
11926                                 Mod_BuildNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchnormal3f, true);
11927                                 rsurface.batchnormal3f = rsurface.array_batchnormal3f;
11928                                 rsurface.batchnormal3f_vertexbuffer = NULL;
11929                                 rsurface.batchnormal3f_bufferoffset = 0;
11930                         }
11931                         if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL
11932                         {
11933                                 Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.array_batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchsvector3f, rsurface.array_batchtvector3f, true);
11934                                 rsurface.batchsvector3f = rsurface.array_batchsvector3f;
11935                                 rsurface.batchsvector3f_vertexbuffer = NULL;
11936                                 rsurface.batchsvector3f_bufferoffset = 0;
11937                                 rsurface.batchtvector3f = rsurface.array_batchtvector3f;
11938                                 rsurface.batchtvector3f_vertexbuffer = NULL;
11939                                 rsurface.batchtvector3f_bufferoffset = 0;
11940                         }
11941                         break;
11942                 case Q3DEFORM_NORMAL:
11943                         // deform the normals to make reflections wavey
11944                         for (j = 0;j < rsurface.batchnumvertices;j++)
11945                         {
11946                                 float vertex[3];
11947                                 float *normal = rsurface.array_batchnormal3f + 3*j;
11948                                 VectorScale(rsurface.batchvertex3f + 3*j, 0.98f, vertex);
11949                                 normal[0] = rsurface.batchnormal3f[j*3+0] + deform->parms[0] * noise4f(      vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
11950                                 normal[1] = rsurface.batchnormal3f[j*3+1] + deform->parms[0] * noise4f( 98 + vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
11951                                 normal[2] = rsurface.batchnormal3f[j*3+2] + deform->parms[0] * noise4f(196 + vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
11952                                 VectorNormalize(normal);
11953                         }
11954                         rsurface.batchnormal3f = rsurface.array_batchnormal3f;
11955                         rsurface.batchnormal3f_vertexbuffer = NULL;
11956                         rsurface.batchnormal3f_bufferoffset = 0;
11957                         if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL
11958                         {
11959                                 Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.array_batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchsvector3f, rsurface.array_batchtvector3f, true);
11960                                 rsurface.batchsvector3f = rsurface.array_batchsvector3f;
11961                                 rsurface.batchsvector3f_vertexbuffer = NULL;
11962                                 rsurface.batchsvector3f_bufferoffset = 0;
11963                                 rsurface.batchtvector3f = rsurface.array_batchtvector3f;
11964                                 rsurface.batchtvector3f_vertexbuffer = NULL;
11965                                 rsurface.batchtvector3f_bufferoffset = 0;
11966                         }
11967                         break;
11968                 case Q3DEFORM_WAVE:
11969                         // deform vertex array to make wavey water and flags and such
11970                         waveparms[0] = deform->waveparms[0];
11971                         waveparms[1] = deform->waveparms[1];
11972                         waveparms[2] = deform->waveparms[2];
11973                         waveparms[3] = deform->waveparms[3];
11974                         if(!R_TestQ3WaveFunc(deform->wavefunc, waveparms))
11975                                 break; // if wavefunc is a nop, don't make a dynamic vertex array
11976                         // this is how a divisor of vertex influence on deformation
11977                         animpos = deform->parms[0] ? 1.0f / deform->parms[0] : 100.0f;
11978                         scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
11979                         for (j = 0;j < rsurface.batchnumvertices;j++)
11980                         {
11981                                 // if the wavefunc depends on time, evaluate it per-vertex
11982                                 if (waveparms[3])
11983                                 {
11984                                         waveparms[2] = deform->waveparms[2] + (rsurface.batchvertex3f[j*3+0] + rsurface.batchvertex3f[j*3+1] + rsurface.batchvertex3f[j*3+2]) * animpos;
11985                                         scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
11986                                 }
11987                                 VectorMA(rsurface.batchvertex3f + 3*j, scale, rsurface.batchnormal3f + 3*j, rsurface.array_batchvertex3f + 3*j);
11988                         }
11989                         // if we get here, BATCHNEED_ARRAY_NORMAL is in batchneed, so no need to check
11990                         Mod_BuildNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchnormal3f, true);
11991                         rsurface.batchvertex3f = rsurface.array_batchvertex3f;
11992                         rsurface.batchvertex3f_vertexbuffer = NULL;
11993                         rsurface.batchvertex3f_bufferoffset = 0;
11994                         rsurface.batchnormal3f = rsurface.array_batchnormal3f;
11995                         rsurface.batchnormal3f_vertexbuffer = NULL;
11996                         rsurface.batchnormal3f_bufferoffset = 0;
11997                         if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL
11998                         {
11999                                 Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.array_batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchsvector3f, rsurface.array_batchtvector3f, true);
12000                                 rsurface.batchsvector3f = rsurface.array_batchsvector3f;
12001                                 rsurface.batchsvector3f_vertexbuffer = NULL;
12002                                 rsurface.batchsvector3f_bufferoffset = 0;
12003                                 rsurface.batchtvector3f = rsurface.array_batchtvector3f;
12004                                 rsurface.batchtvector3f_vertexbuffer = NULL;
12005                                 rsurface.batchtvector3f_bufferoffset = 0;
12006                         }
12007                         break;
12008                 case Q3DEFORM_BULGE:
12009                         // deform vertex array to make the surface have moving bulges
12010                         for (j = 0;j < rsurface.batchnumvertices;j++)
12011                         {
12012                                 scale = sin(rsurface.batchtexcoordtexture2f[j*2+0] * deform->parms[0] + r_refdef.scene.time * deform->parms[2]) * deform->parms[1];
12013                                 VectorMA(rsurface.batchvertex3f + 3*j, scale, rsurface.batchnormal3f + 3*j, rsurface.array_batchvertex3f + 3*j);
12014                         }
12015                         // if we get here, BATCHNEED_ARRAY_NORMAL is in batchneed, so no need to check
12016                         Mod_BuildNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchnormal3f, true);
12017                         rsurface.batchvertex3f = rsurface.array_batchvertex3f;
12018                         rsurface.batchvertex3f_vertexbuffer = NULL;
12019                         rsurface.batchvertex3f_bufferoffset = 0;
12020                         rsurface.batchnormal3f = rsurface.array_batchnormal3f;
12021                         rsurface.batchnormal3f_vertexbuffer = NULL;
12022                         rsurface.batchnormal3f_bufferoffset = 0;
12023                         if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL
12024                         {
12025                                 Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.array_batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchsvector3f, rsurface.array_batchtvector3f, true);
12026                                 rsurface.batchsvector3f = rsurface.array_batchsvector3f;
12027                                 rsurface.batchsvector3f_vertexbuffer = NULL;
12028                                 rsurface.batchsvector3f_bufferoffset = 0;
12029                                 rsurface.batchtvector3f = rsurface.array_batchtvector3f;
12030                                 rsurface.batchtvector3f_vertexbuffer = NULL;
12031                                 rsurface.batchtvector3f_bufferoffset = 0;
12032                         }
12033                         break;
12034                 case Q3DEFORM_MOVE:
12035                         // deform vertex array
12036                         if(!R_TestQ3WaveFunc(deform->wavefunc, deform->waveparms))
12037                                 break; // if wavefunc is a nop, don't make a dynamic vertex array
12038                         scale = R_EvaluateQ3WaveFunc(deform->wavefunc, deform->waveparms);
12039                         VectorScale(deform->parms, scale, waveparms);
12040                         for (j = 0;j < rsurface.batchnumvertices;j++)
12041                                 VectorAdd(rsurface.batchvertex3f + 3*j, waveparms, rsurface.array_batchvertex3f + 3*j);
12042                         rsurface.batchvertex3f = rsurface.array_batchvertex3f;
12043                         rsurface.batchvertex3f_vertexbuffer = NULL;
12044                         rsurface.batchvertex3f_bufferoffset = 0;
12045                         break;
12046                 }
12047         }
12048
12049         // generate texcoords based on the chosen texcoord source
12050         switch(rsurface.texture->tcgen.tcgen)
12051         {
12052         default:
12053         case Q3TCGEN_TEXTURE:
12054                 break;
12055         case Q3TCGEN_LIGHTMAP:
12056                 if (rsurface.batchtexcoordlightmap2f)
12057                         memcpy(rsurface.array_batchtexcoordlightmap2f, rsurface.batchtexcoordtexture2f, rsurface.batchnumvertices * sizeof(float[2]));
12058                 rsurface.batchtexcoordtexture2f = rsurface.array_batchtexcoordtexture2f;
12059                 rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
12060                 rsurface.batchtexcoordtexture2f_bufferoffset = 0;
12061                 break;
12062         case Q3TCGEN_VECTOR:
12063                 for (j = 0;j < rsurface.batchnumvertices;j++)
12064                 {
12065                         rsurface.array_batchtexcoordtexture2f[j*2+0] = DotProduct(rsurface.batchvertex3f + 3*j, rsurface.texture->tcgen.parms);
12066                         rsurface.array_batchtexcoordtexture2f[j*2+1] = DotProduct(rsurface.batchvertex3f + 3*j, rsurface.texture->tcgen.parms + 3);
12067                 }
12068                 rsurface.batchtexcoordtexture2f = rsurface.array_batchtexcoordtexture2f;
12069                 rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
12070                 rsurface.batchtexcoordtexture2f_bufferoffset = 0;
12071                 break;
12072         case Q3TCGEN_ENVIRONMENT:
12073                 // make environment reflections using a spheremap
12074                 for (j = 0;j < rsurface.batchnumvertices;j++)
12075                 {
12076                         // identical to Q3A's method, but executed in worldspace so
12077                         // carried models can be shiny too
12078
12079                         float viewer[3], d, reflected[3], worldreflected[3];
12080
12081                         VectorSubtract(rsurface.localvieworigin, rsurface.batchvertex3f + 3*j, viewer);
12082                         // VectorNormalize(viewer);
12083
12084                         d = DotProduct(rsurface.batchnormal3f + 3*j, viewer);
12085
12086                         reflected[0] = rsurface.batchnormal3f[j*3+0]*2*d - viewer[0];
12087                         reflected[1] = rsurface.batchnormal3f[j*3+1]*2*d - viewer[1];
12088                         reflected[2] = rsurface.batchnormal3f[j*3+2]*2*d - viewer[2];
12089                         // note: this is proportinal to viewer, so we can normalize later
12090
12091                         Matrix4x4_Transform3x3(&rsurface.matrix, reflected, worldreflected);
12092                         VectorNormalize(worldreflected);
12093
12094                         // note: this sphere map only uses world x and z!
12095                         // so positive and negative y will LOOK THE SAME.
12096                         rsurface.array_batchtexcoordtexture2f[j*2+0] = 0.5 + 0.5 * worldreflected[1];
12097                         rsurface.array_batchtexcoordtexture2f[j*2+1] = 0.5 - 0.5 * worldreflected[2];
12098                 }
12099                 rsurface.batchtexcoordtexture2f = rsurface.array_batchtexcoordtexture2f;
12100                 rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
12101                 rsurface.batchtexcoordtexture2f_bufferoffset = 0;
12102                 break;
12103         }
12104         // the only tcmod that needs software vertex processing is turbulent, so
12105         // check for it here and apply the changes if needed
12106         // and we only support that as the first one
12107         // (handling a mixture of turbulent and other tcmods would be problematic
12108         //  without punting it entirely to a software path)
12109         if (rsurface.texture->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
12110         {
12111                 amplitude = rsurface.texture->tcmods[0].parms[1];
12112                 animpos = rsurface.texture->tcmods[0].parms[2] + r_refdef.scene.time * rsurface.texture->tcmods[0].parms[3];
12113                 for (j = 0;j < rsurface.batchnumvertices;j++)
12114                 {
12115                         rsurface.array_batchtexcoordtexture2f[j*2+0] += amplitude * sin(((rsurface.batchvertex3f[j*3+0] + rsurface.batchvertex3f[j*3+2]) * 1.0 / 1024.0f + animpos) * M_PI * 2);
12116                         rsurface.array_batchtexcoordtexture2f[j*2+1] += amplitude * sin(((rsurface.batchvertex3f[j*3+1]                                ) * 1.0 / 1024.0f + animpos) * M_PI * 2);
12117                 }
12118                 rsurface.batchtexcoordtexture2f = rsurface.array_batchtexcoordtexture2f;
12119                 rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
12120                 rsurface.batchtexcoordtexture2f_bufferoffset = 0;
12121         }
12122
12123         if (needsupdate & batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP))
12124         {
12125                 // convert the modified arrays to vertex structs
12126                 rsurface.batchvertexmesh = rsurface.array_batchvertexmesh;
12127                 rsurface.batchvertexmeshbuffer = NULL;
12128                 if (batchneed & BATCHNEED_VERTEXMESH_VERTEX)
12129                         for (j = 0, vertexmesh = rsurface.array_batchvertexmesh;j < rsurface.batchnumvertices;j++, vertexmesh++)
12130                                 VectorCopy(rsurface.batchvertex3f + 3*j, vertexmesh->vertex3f);
12131                 if (batchneed & BATCHNEED_VERTEXMESH_NORMAL)
12132                         for (j = 0, vertexmesh = rsurface.array_batchvertexmesh;j < rsurface.batchnumvertices;j++, vertexmesh++)
12133                                 VectorCopy(rsurface.batchnormal3f + 3*j, vertexmesh->normal3f);
12134                 if (batchneed & BATCHNEED_VERTEXMESH_VECTOR)
12135                 {
12136                         for (j = 0, vertexmesh = rsurface.array_batchvertexmesh;j < rsurface.batchnumvertices;j++, vertexmesh++)
12137                         {
12138                                 VectorCopy(rsurface.batchsvector3f + 3*j, vertexmesh->svector3f);
12139                                 VectorCopy(rsurface.batchtvector3f + 3*j, vertexmesh->tvector3f);
12140                         }
12141                 }
12142                 if ((batchneed & BATCHNEED_VERTEXMESH_VERTEXCOLOR) && rsurface.batchlightmapcolor4f)
12143                         for (j = 0, vertexmesh = rsurface.array_batchvertexmesh;j < rsurface.batchnumvertices;j++, vertexmesh++)
12144                                 Vector4Scale(rsurface.batchlightmapcolor4f + 4*j, 255.0f, vertexmesh->color4ub);
12145                 if (batchneed & BATCHNEED_VERTEXMESH_TEXCOORD)
12146                         for (j = 0, vertexmesh = rsurface.array_batchvertexmesh;j < rsurface.batchnumvertices;j++, vertexmesh++)
12147                                 Vector2Copy(rsurface.batchtexcoordtexture2f + 2*j, vertexmesh->texcoordtexture2f);
12148                 if ((batchneed & BATCHNEED_VERTEXMESH_LIGHTMAP) && rsurface.batchtexcoordlightmap2f)
12149                         for (j = 0, vertexmesh = rsurface.array_batchvertexmesh;j < rsurface.batchnumvertices;j++, vertexmesh++)
12150                                 Vector2Copy(rsurface.batchtexcoordlightmap2f + 2*j, vertexmesh->texcoordlightmap2f);
12151         }
12152
12153         if (needsupdate & batchneed & BATCHNEED_VERTEXPOSITION)
12154         {
12155                 // convert the modified arrays to vertex structs
12156                 rsurface.batchvertexposition = rsurface.array_batchvertexposition;
12157                 rsurface.batchvertexpositionbuffer = NULL;
12158                 if (sizeof(r_vertexposition_t) == sizeof(float[3]))
12159                         memcpy(rsurface.array_batchvertexposition, rsurface.batchvertex3f, rsurface.batchnumvertices * sizeof(r_vertexposition_t));
12160                 else
12161                         for (j = 0, vertexposition = rsurface.array_batchvertexposition;j < rsurface.batchnumvertices;j++, vertexposition++)
12162                                 VectorCopy(rsurface.batchvertex3f + 3*j, vertexposition->vertex3f);
12163         }
12164 }
12165
12166 void RSurf_DrawBatch(void)
12167 {
12168         R_Mesh_Draw(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchfirsttriangle, rsurface.batchnumtriangles, rsurface.batchelement3i, rsurface.batchelement3i_indexbuffer, rsurface.batchelement3i_bufferoffset, rsurface.batchelement3s, rsurface.batchelement3s_indexbuffer, rsurface.batchelement3s_bufferoffset);
12169 }
12170
12171 static int RSurf_FindWaterPlaneForSurface(const msurface_t *surface)
12172 {
12173         // pick the closest matching water plane
12174         int planeindex, vertexindex, bestplaneindex = -1;
12175         float d, bestd;
12176         vec3_t vert;
12177         const float *v;
12178         r_waterstate_waterplane_t *p;
12179         bestd = 0;
12180         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
12181         {
12182                 if(p->camera_entity != rsurface.texture->camera_entity)
12183                         continue;
12184                 d = 0;
12185                 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX, 1, &surface);
12186                 for (vertexindex = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3;vertexindex < rsurface.batchnumvertices;vertexindex++, v += 3)
12187                 {
12188                         Matrix4x4_Transform(&rsurface.matrix, v, vert);
12189                         d += fabs(PlaneDiff(vert, &p->plane));
12190                 }
12191                 if (bestd > d || bestplaneindex < 0)
12192                 {
12193                         bestd = d;
12194                         bestplaneindex = planeindex;
12195                 }
12196         }
12197         return bestplaneindex;
12198 }
12199
12200 static void RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray(void)
12201 {
12202         int i;
12203         for (i = 0;i < rsurface.batchnumvertices;i++)
12204                 Vector4Set(rsurface.array_passcolor4f + 4*i, 0.5f, 0.5f, 0.5f, 1.0f);
12205         rsurface.passcolor4f = rsurface.array_passcolor4f;
12206         rsurface.passcolor4f_vertexbuffer = 0;
12207         rsurface.passcolor4f_bufferoffset = 0;
12208 }
12209
12210 static void RSurf_DrawBatch_GL11_ApplyFog(void)
12211 {
12212         int i;
12213         float f;
12214         const float *v;
12215         const float *c;
12216         float *c2;
12217         if (rsurface.passcolor4f)
12218         {
12219                 // generate color arrays
12220                 for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4, c2 = rsurface.array_passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, c += 4, c2 += 4)
12221                 {
12222                         f = RSurf_FogVertex(v);
12223                         c2[0] = c[0] * f;
12224                         c2[1] = c[1] * f;
12225                         c2[2] = c[2] * f;
12226                         c2[3] = c[3];
12227                 }
12228         }
12229         else
12230         {
12231                 for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, c2 = rsurface.array_passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, c2 += 4)
12232                 {
12233                         f = RSurf_FogVertex(v);
12234                         c2[0] = f;
12235                         c2[1] = f;
12236                         c2[2] = f;
12237                         c2[3] = 1;
12238                 }
12239         }
12240         rsurface.passcolor4f = rsurface.array_passcolor4f;
12241         rsurface.passcolor4f_vertexbuffer = 0;
12242         rsurface.passcolor4f_bufferoffset = 0;
12243 }
12244
12245 static void RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors(void)
12246 {
12247         int i;
12248         float f;
12249         const float *v;
12250         const float *c;
12251         float *c2;
12252         if (!rsurface.passcolor4f)
12253                 return;
12254         for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4, c2 = rsurface.array_passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, c += 4, c2 += 4)
12255         {
12256                 f = RSurf_FogVertex(v);
12257                 c2[0] = c[0] * f + r_refdef.fogcolor[0] * (1 - f);
12258                 c2[1] = c[1] * f + r_refdef.fogcolor[1] * (1 - f);
12259                 c2[2] = c[2] * f + r_refdef.fogcolor[2] * (1 - f);
12260                 c2[3] = c[3];
12261         }
12262         rsurface.passcolor4f = rsurface.array_passcolor4f;
12263         rsurface.passcolor4f_vertexbuffer = 0;
12264         rsurface.passcolor4f_bufferoffset = 0;
12265 }
12266
12267 static void RSurf_DrawBatch_GL11_ApplyColor(float r, float g, float b, float a)
12268 {
12269         int i;
12270         const float *c;
12271         float *c2;
12272         if (!rsurface.passcolor4f)
12273                 return;
12274         for (i = 0, c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4, c2 = rsurface.array_passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, c += 4, c2 += 4)
12275         {
12276                 c2[0] = c[0] * r;
12277                 c2[1] = c[1] * g;
12278                 c2[2] = c[2] * b;
12279                 c2[3] = c[3] * a;
12280         }
12281         rsurface.passcolor4f = rsurface.array_passcolor4f;
12282         rsurface.passcolor4f_vertexbuffer = 0;
12283         rsurface.passcolor4f_bufferoffset = 0;
12284 }
12285
12286 static void RSurf_DrawBatch_GL11_ApplyAmbient(void)
12287 {
12288         int i;
12289         const float *c;
12290         float *c2;
12291         if (!rsurface.passcolor4f)
12292                 return;
12293         for (i = 0, c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4, c2 = rsurface.array_passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, c += 4, c2 += 4)
12294         {
12295                 c2[0] = c[0] + r_refdef.scene.ambient;
12296                 c2[1] = c[1] + r_refdef.scene.ambient;
12297                 c2[2] = c[2] + r_refdef.scene.ambient;
12298                 c2[3] = c[3];
12299         }
12300         rsurface.passcolor4f = rsurface.array_passcolor4f;
12301         rsurface.passcolor4f_vertexbuffer = 0;
12302         rsurface.passcolor4f_bufferoffset = 0;
12303 }
12304
12305 static void RSurf_DrawBatch_GL11_Lightmap(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
12306 {
12307         // TODO: optimize
12308         rsurface.passcolor4f = NULL;
12309         rsurface.passcolor4f_vertexbuffer = 0;
12310         rsurface.passcolor4f_bufferoffset = 0;
12311         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog();
12312         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
12313         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
12314         GL_Color(r, g, b, a);
12315         R_Mesh_TexBind(0, rsurface.lightmaptexture);
12316         RSurf_DrawBatch();
12317 }
12318
12319 static void RSurf_DrawBatch_GL11_Unlit(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
12320 {
12321         // TODO: optimize applyfog && applycolor case
12322         // just apply fog if necessary, and tint the fog color array if necessary
12323         rsurface.passcolor4f = NULL;
12324         rsurface.passcolor4f_vertexbuffer = 0;
12325         rsurface.passcolor4f_bufferoffset = 0;
12326         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog();
12327         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
12328         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
12329         GL_Color(r, g, b, a);
12330         RSurf_DrawBatch();
12331 }
12332
12333 static void RSurf_DrawBatch_GL11_VertexColor(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
12334 {
12335         // TODO: optimize
12336         rsurface.passcolor4f = rsurface.batchlightmapcolor4f;
12337         rsurface.passcolor4f_vertexbuffer = rsurface.batchlightmapcolor4f_vertexbuffer;
12338         rsurface.passcolor4f_bufferoffset = rsurface.batchlightmapcolor4f_bufferoffset;
12339         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog();
12340         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
12341         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
12342         GL_Color(r, g, b, a);
12343         RSurf_DrawBatch();
12344 }
12345
12346 static void RSurf_DrawBatch_GL11_ClampColor(void)
12347 {
12348         int i;
12349         const float *c1;
12350         float *c2;
12351         if (!rsurface.passcolor4f)
12352                 return;
12353         for (i = 0, c1 = rsurface.passcolor4f + 4*rsurface.batchfirstvertex, c2 = rsurface.array_passcolor4f + 4*rsurface.batchfirstvertex;i < rsurface.batchnumvertices;i++, c1 += 4, c2 += 4)
12354         {
12355                 c2[0] = bound(0.0f, c1[0], 1.0f);
12356                 c2[1] = bound(0.0f, c1[1], 1.0f);
12357                 c2[2] = bound(0.0f, c1[2], 1.0f);
12358                 c2[3] = bound(0.0f, c1[3], 1.0f);
12359         }
12360 }
12361
12362 static void RSurf_DrawBatch_GL11_ApplyFakeLight(void)
12363 {
12364         int i;
12365         float f;
12366         const float *v;
12367         const float *n;
12368         float *c;
12369         //vec3_t eyedir;
12370
12371         // fake shading
12372         for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, n = rsurface.batchnormal3f + rsurface.batchfirstvertex * 3, c = rsurface.array_passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, n += 3, c += 4)
12373         {
12374                 f = -DotProduct(r_refdef.view.forward, n);
12375                 f = max(0, f);
12376                 f = f * 0.85 + 0.15; // work around so stuff won't get black
12377                 f *= r_refdef.lightmapintensity;
12378                 Vector4Set(c, f, f, f, 1);
12379         }
12380
12381         rsurface.passcolor4f = rsurface.array_passcolor4f;
12382         rsurface.passcolor4f_vertexbuffer = 0;
12383         rsurface.passcolor4f_bufferoffset = 0;
12384 }
12385
12386 static void RSurf_DrawBatch_GL11_FakeLight(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
12387 {
12388         RSurf_DrawBatch_GL11_ApplyFakeLight();
12389         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog();
12390         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
12391         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
12392         GL_Color(r, g, b, a);
12393         RSurf_DrawBatch();
12394 }
12395
12396 static void RSurf_DrawBatch_GL11_ApplyVertexShade(float *r, float *g, float *b, float *a, qboolean *applycolor)
12397 {
12398         int i;
12399         float f;
12400         float alpha;
12401         const float *v;
12402         const float *n;
12403         float *c;
12404         vec3_t ambientcolor;
12405         vec3_t diffusecolor;
12406         vec3_t lightdir;
12407         // TODO: optimize
12408         // model lighting
12409         VectorCopy(rsurface.modellight_lightdir, lightdir);
12410         f = 0.5f * r_refdef.lightmapintensity;
12411         ambientcolor[0] = rsurface.modellight_ambient[0] * *r * f;
12412         ambientcolor[1] = rsurface.modellight_ambient[1] * *g * f;
12413         ambientcolor[2] = rsurface.modellight_ambient[2] * *b * f;
12414         diffusecolor[0] = rsurface.modellight_diffuse[0] * *r * f;
12415         diffusecolor[1] = rsurface.modellight_diffuse[1] * *g * f;
12416         diffusecolor[2] = rsurface.modellight_diffuse[2] * *b * f;
12417         alpha = *a;
12418         if (VectorLength2(diffusecolor) > 0)
12419         {
12420                 // q3-style directional shading
12421                 for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, n = rsurface.batchnormal3f + rsurface.batchfirstvertex * 3, c = rsurface.array_passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, n += 3, c += 4)
12422                 {
12423                         if ((f = DotProduct(n, lightdir)) > 0)
12424                                 VectorMA(ambientcolor, f, diffusecolor, c);
12425                         else
12426                                 VectorCopy(ambientcolor, c);
12427                         c[3] = alpha;
12428                 }
12429                 *r = 1;
12430                 *g = 1;
12431                 *b = 1;
12432                 *a = 1;
12433                 rsurface.passcolor4f = rsurface.array_passcolor4f;
12434                 rsurface.passcolor4f_vertexbuffer = 0;
12435                 rsurface.passcolor4f_bufferoffset = 0;
12436                 *applycolor = false;
12437         }
12438         else
12439         {
12440                 *r = ambientcolor[0];
12441                 *g = ambientcolor[1];
12442                 *b = ambientcolor[2];
12443                 rsurface.passcolor4f = NULL;
12444                 rsurface.passcolor4f_vertexbuffer = 0;
12445                 rsurface.passcolor4f_bufferoffset = 0;
12446         }
12447 }
12448
12449 static void RSurf_DrawBatch_GL11_VertexShade(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
12450 {
12451         RSurf_DrawBatch_GL11_ApplyVertexShade(&r, &g, &b, &a, &applycolor);
12452         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog();
12453         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
12454         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
12455         GL_Color(r, g, b, a);
12456         RSurf_DrawBatch();
12457 }
12458
12459 static void RSurf_DrawBatch_GL11_MakeFogColor(float r, float g, float b, float a)
12460 {
12461         int i;
12462         float f;
12463         const float *v;
12464         float *c;
12465         for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, c = rsurface.array_passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, c += 4)
12466         {
12467                 f = 1 - RSurf_FogVertex(v);
12468                 c[0] = r;
12469                 c[1] = g;
12470                 c[2] = b;
12471                 c[3] = f * a;
12472         }
12473 }
12474
12475 void RSurf_SetupDepthAndCulling(void)
12476 {
12477         // submodels are biased to avoid z-fighting with world surfaces that they
12478         // may be exactly overlapping (avoids z-fighting artifacts on certain
12479         // doors and things in Quake maps)
12480         GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
12481         GL_PolygonOffset(rsurface.basepolygonfactor + rsurface.texture->biaspolygonfactor, rsurface.basepolygonoffset + rsurface.texture->biaspolygonoffset);
12482         GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
12483         GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_refdef.view.cullface_back);
12484 }
12485
12486 static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, const msurface_t **texturesurfacelist)
12487 {
12488         // transparent sky would be ridiculous
12489         if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
12490                 return;
12491         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
12492         skyrenderlater = true;
12493         RSurf_SetupDepthAndCulling();
12494         GL_DepthMask(true);
12495         // LordHavoc: HalfLife maps have freaky skypolys so don't use
12496         // skymasking on them, and Quake3 never did sky masking (unlike
12497         // software Quake and software Quake2), so disable the sky masking
12498         // in Quake3 maps as it causes problems with q3map2 sky tricks,
12499         // and skymasking also looks very bad when noclipping outside the
12500         // level, so don't use it then either.
12501         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_refdef.viewcache.world_novis)
12502         {
12503                 R_Mesh_ResetTextureState();
12504                 if (skyrendermasked)
12505                 {
12506                         R_SetupShader_DepthOrShadow();
12507                         // depth-only (masking)
12508                         GL_ColorMask(0,0,0,0);
12509                         // just to make sure that braindead drivers don't draw
12510                         // anything despite that colormask...
12511                         GL_BlendFunc(GL_ZERO, GL_ONE);
12512                         RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXPOSITION | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12513                         R_Mesh_PrepareVertices_Position(rsurface.batchnumvertices, rsurface.batchvertexposition, rsurface.batchvertexpositionbuffer);
12514                 }
12515                 else
12516                 {
12517                         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
12518                         // fog sky
12519                         GL_BlendFunc(GL_ONE, GL_ZERO);
12520                         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12521                         GL_Color(r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2], 1);
12522                         R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, NULL, NULL);
12523                 }
12524                 RSurf_DrawBatch();
12525                 if (skyrendermasked)
12526                         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
12527         }
12528         R_Mesh_ResetTextureState();
12529         GL_Color(1, 1, 1, 1);
12530 }
12531
12532 extern rtexture_t *r_shadow_prepasslightingdiffusetexture;
12533 extern rtexture_t *r_shadow_prepasslightingspeculartexture;
12534 static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
12535 {
12536         if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA)))
12537                 return;
12538         if (prepass)
12539         {
12540                 // render screenspace normalmap to texture
12541                 GL_DepthMask(true);
12542                 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_DEFERREDGEOMETRY, texturenumsurfaces, texturesurfacelist, NULL);
12543                 RSurf_DrawBatch();
12544                 return;
12545         }
12546
12547         // bind lightmap texture
12548
12549         // water/refraction/reflection/camera surfaces have to be handled specially
12550         if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_CAMERA | MATERIALFLAG_REFLECTION)) && !r_waterstate.renderingscene)
12551         {
12552                 int start, end, startplaneindex;
12553                 for (start = 0;start < texturenumsurfaces;start = end)
12554                 {
12555                         startplaneindex = RSurf_FindWaterPlaneForSurface(texturesurfacelist[start]);
12556                         for (end = start + 1;end < texturenumsurfaces && startplaneindex == RSurf_FindWaterPlaneForSurface(texturesurfacelist[end]);end++)
12557                                 ;
12558                         // now that we have a batch using the same planeindex, render it
12559                         if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_CAMERA)) && !r_waterstate.renderingscene)
12560                         {
12561                                 // render water or distortion background
12562                                 GL_DepthMask(true);
12563                                 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BACKGROUND, end-start, texturesurfacelist + start, (void *)(r_waterstate.waterplanes + startplaneindex));
12564                                 RSurf_DrawBatch();
12565                                 // blend surface on top
12566                                 GL_DepthMask(false);
12567                                 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE, end-start, texturesurfacelist + start, NULL);
12568                                 RSurf_DrawBatch();
12569                         }
12570                         else if ((rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION) && !r_waterstate.renderingscene)
12571                         {
12572                                 // render surface with reflection texture as input
12573                                 GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED));
12574                                 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE, end-start, texturesurfacelist + start, (void *)(r_waterstate.waterplanes + startplaneindex));
12575                                 RSurf_DrawBatch();
12576                         }
12577                 }
12578                 return;
12579         }
12580
12581         // render surface batch normally
12582         GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED));
12583         R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE, texturenumsurfaces, texturesurfacelist, NULL);
12584         RSurf_DrawBatch();
12585 }
12586
12587 static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
12588 {
12589         // OpenGL 1.3 path - anything not completely ancient
12590         qboolean applycolor;
12591         qboolean applyfog;
12592         int layerindex;
12593         const texturelayer_t *layer;
12594         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | ((!rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) ? BATCHNEED_ARRAY_VERTEXCOLOR : 0) | BATCHNEED_ARRAY_TEXCOORD | (rsurface.modeltexcoordlightmap2f ? BATCHNEED_ARRAY_LIGHTMAP : 0) | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12595         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
12596
12597         for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
12598         {
12599                 vec4_t layercolor;
12600                 int layertexrgbscale;
12601                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
12602                 {
12603                         if (layerindex == 0)
12604                                 GL_AlphaTest(true);
12605                         else
12606                         {
12607                                 GL_AlphaTest(false);
12608                                 GL_DepthFunc(GL_EQUAL);
12609                         }
12610                 }
12611                 GL_DepthMask(layer->depthmask && writedepth);
12612                 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
12613                 if (layer->color[0] > 2 || layer->color[1] > 2 || layer->color[2] > 2)
12614                 {
12615                         layertexrgbscale = 4;
12616                         VectorScale(layer->color, 0.25f, layercolor);
12617                 }
12618                 else if (layer->color[0] > 1 || layer->color[1] > 1 || layer->color[2] > 1)
12619                 {
12620                         layertexrgbscale = 2;
12621                         VectorScale(layer->color, 0.5f, layercolor);
12622                 }
12623                 else
12624                 {
12625                         layertexrgbscale = 1;
12626                         VectorScale(layer->color, 1.0f, layercolor);
12627                 }
12628                 layercolor[3] = layer->color[3];
12629                 applycolor = layercolor[0] != 1 || layercolor[1] != 1 || layercolor[2] != 1 || layercolor[3] != 1;
12630                 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, 0, 0);
12631                 applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
12632                 switch (layer->type)
12633                 {
12634                 case TEXTURELAYERTYPE_LITTEXTURE:
12635                         // single-pass lightmapped texture with 2x rgbscale
12636                         R_Mesh_TexBind(0, r_texture_white);
12637                         R_Mesh_TexMatrix(0, NULL);
12638                         R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
12639                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordlightmap2f_vertexbuffer, rsurface.batchtexcoordlightmap2f_bufferoffset);
12640                         R_Mesh_TexBind(1, layer->texture);
12641                         R_Mesh_TexMatrix(1, &layer->texmatrix);
12642                         R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
12643                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
12644                         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
12645                                 RSurf_DrawBatch_GL11_VertexShade(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
12646                         else if (FAKELIGHT_ENABLED)
12647                                 RSurf_DrawBatch_GL11_FakeLight(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
12648                         else if (rsurface.uselightmaptexture)
12649                                 RSurf_DrawBatch_GL11_Lightmap(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
12650                         else
12651                                 RSurf_DrawBatch_GL11_VertexColor(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
12652                         break;
12653                 case TEXTURELAYERTYPE_TEXTURE:
12654                         // singletexture unlit texture with transparency support
12655                         R_Mesh_TexBind(0, layer->texture);
12656                         R_Mesh_TexMatrix(0, &layer->texmatrix);
12657                         R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
12658                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
12659                         R_Mesh_TexBind(1, 0);
12660                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, 0, 0);
12661                         RSurf_DrawBatch_GL11_Unlit(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
12662                         break;
12663                 case TEXTURELAYERTYPE_FOG:
12664                         // singletexture fogging
12665                         if (layer->texture)
12666                         {
12667                                 R_Mesh_TexBind(0, layer->texture);
12668                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
12669                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
12670                                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
12671                         }
12672                         else
12673                         {
12674                                 R_Mesh_TexBind(0, 0);
12675                                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, 0, 0);
12676                         }
12677                         R_Mesh_TexBind(1, 0);
12678                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, 0, 0);
12679                         // generate a color array for the fog pass
12680                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.array_passcolor4f, 0, 0);
12681                         RSurf_DrawBatch_GL11_MakeFogColor(layercolor[0], layercolor[1], layercolor[2], layercolor[3]);
12682                         RSurf_DrawBatch();
12683                         break;
12684                 default:
12685                         Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
12686                 }
12687         }
12688         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
12689         {
12690                 GL_DepthFunc(GL_LEQUAL);
12691                 GL_AlphaTest(false);
12692         }
12693 }
12694
12695 static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
12696 {
12697         // OpenGL 1.1 - crusty old voodoo path
12698         qboolean applyfog;
12699         int layerindex;
12700         const texturelayer_t *layer;
12701         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | ((!rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) ? BATCHNEED_ARRAY_VERTEXCOLOR : 0) | BATCHNEED_ARRAY_TEXCOORD | (rsurface.modeltexcoordlightmap2f ? BATCHNEED_ARRAY_LIGHTMAP : 0) | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12702         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
12703
12704         for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
12705         {
12706                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
12707                 {
12708                         if (layerindex == 0)
12709                                 GL_AlphaTest(true);
12710                         else
12711                         {
12712                                 GL_AlphaTest(false);
12713                                 GL_DepthFunc(GL_EQUAL);
12714                         }
12715                 }
12716                 GL_DepthMask(layer->depthmask && writedepth);
12717                 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
12718                 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, 0, 0);
12719                 applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
12720                 switch (layer->type)
12721                 {
12722                 case TEXTURELAYERTYPE_LITTEXTURE:
12723                         if (layer->blendfunc1 == GL_ONE && layer->blendfunc2 == GL_ZERO)
12724                         {
12725                                 // two-pass lit texture with 2x rgbscale
12726                                 // first the lightmap pass
12727                                 R_Mesh_TexBind(0, r_texture_white);
12728                                 R_Mesh_TexMatrix(0, NULL);
12729                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
12730                                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordlightmap2f_vertexbuffer, rsurface.batchtexcoordlightmap2f_bufferoffset);
12731                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
12732                                         RSurf_DrawBatch_GL11_VertexShade(1, 1, 1, 1, false, false);
12733                                 else if (FAKELIGHT_ENABLED)
12734                                         RSurf_DrawBatch_GL11_FakeLight(1, 1, 1, 1, false, false);
12735                                 else if (rsurface.uselightmaptexture)
12736                                         RSurf_DrawBatch_GL11_Lightmap(1, 1, 1, 1, false, false);
12737                                 else
12738                                         RSurf_DrawBatch_GL11_VertexColor(1, 1, 1, 1, false, false);
12739                                 // then apply the texture to it
12740                                 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
12741                                 R_Mesh_TexBind(0, layer->texture);
12742                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
12743                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
12744                                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
12745                                 RSurf_DrawBatch_GL11_Unlit(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);
12746                         }
12747                         else
12748                         {
12749                                 // single pass vertex-lighting-only texture with 1x rgbscale and transparency support
12750                                 R_Mesh_TexBind(0, layer->texture);
12751                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
12752                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
12753                                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
12754                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
12755                                         RSurf_DrawBatch_GL11_VertexShade(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);
12756                                 else
12757                                         RSurf_DrawBatch_GL11_VertexColor(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);
12758                         }
12759                         break;
12760                 case TEXTURELAYERTYPE_TEXTURE:
12761                         // singletexture unlit texture with transparency support
12762                         R_Mesh_TexBind(0, layer->texture);
12763                         R_Mesh_TexMatrix(0, &layer->texmatrix);
12764                         R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
12765                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
12766                         RSurf_DrawBatch_GL11_Unlit(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);
12767                         break;
12768                 case TEXTURELAYERTYPE_FOG:
12769                         // singletexture fogging
12770                         if (layer->texture)
12771                         {
12772                                 R_Mesh_TexBind(0, layer->texture);
12773                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
12774                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
12775                                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
12776                         }
12777                         else
12778                         {
12779                                 R_Mesh_TexBind(0, 0);
12780                                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, 0, 0);
12781                         }
12782                         // generate a color array for the fog pass
12783                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.array_passcolor4f, 0, 0);
12784                         RSurf_DrawBatch_GL11_MakeFogColor(layer->color[0], layer->color[1], layer->color[2], layer->color[3]);
12785                         RSurf_DrawBatch();
12786                         break;
12787                 default:
12788                         Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
12789                 }
12790         }
12791         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
12792         {
12793                 GL_DepthFunc(GL_LEQUAL);
12794                 GL_AlphaTest(false);
12795         }
12796 }
12797
12798 static void R_DrawTextureSurfaceList_ShowSurfaces(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
12799 {
12800         int vi;
12801         int j;
12802         r_vertexgeneric_t *batchvertex;
12803         float c[4];
12804
12805         GL_AlphaTest(false);
12806         R_Mesh_ResetTextureState();
12807         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
12808
12809         if(rsurface.texture && rsurface.texture->currentskinframe)
12810         {
12811                 memcpy(c, rsurface.texture->currentskinframe->avgcolor, sizeof(c));
12812                 c[3] *= rsurface.texture->currentalpha;
12813         }
12814         else
12815         {
12816                 c[0] = 1;
12817                 c[1] = 0;
12818                 c[2] = 1;
12819                 c[3] = 1;
12820         }
12821
12822         if (rsurface.texture->pantstexture || rsurface.texture->shirttexture)
12823         {
12824                 c[0] = 0.5 * (rsurface.colormap_pantscolor[0] * 0.3 + rsurface.colormap_shirtcolor[0] * 0.7);
12825                 c[1] = 0.5 * (rsurface.colormap_pantscolor[1] * 0.3 + rsurface.colormap_shirtcolor[1] * 0.7);
12826                 c[2] = 0.5 * (rsurface.colormap_pantscolor[2] * 0.3 + rsurface.colormap_shirtcolor[2] * 0.7);
12827         }
12828
12829         // brighten it up (as texture value 127 means "unlit")
12830         c[0] *= 2 * r_refdef.view.colorscale;
12831         c[1] *= 2 * r_refdef.view.colorscale;
12832         c[2] *= 2 * r_refdef.view.colorscale;
12833
12834         if(rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERALPHA)
12835                 c[3] *= r_wateralpha.value;
12836
12837         if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHA && c[3] != 1)
12838         {
12839                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
12840                 GL_DepthMask(false);
12841         }
12842         else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
12843         {
12844                 GL_BlendFunc(GL_ONE, GL_ONE);
12845                 GL_DepthMask(false);
12846         }
12847         else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
12848         {
12849                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // can't do alpha test without texture, so let's blend instead
12850                 GL_DepthMask(false);
12851         }
12852         else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
12853         {
12854                 GL_BlendFunc(rsurface.texture->customblendfunc[0], rsurface.texture->customblendfunc[1]);
12855                 GL_DepthMask(false);
12856         }
12857         else
12858         {
12859                 GL_BlendFunc(GL_ONE, GL_ZERO);
12860                 GL_DepthMask(writedepth);
12861         }
12862
12863         if (r_showsurfaces.integer == 3)
12864         {
12865                 rsurface.passcolor4f = NULL;
12866
12867                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
12868                 {
12869                         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12870
12871                         rsurface.passcolor4f = NULL;
12872                         rsurface.passcolor4f_vertexbuffer = 0;
12873                         rsurface.passcolor4f_bufferoffset = 0;
12874                 }
12875                 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
12876                 {
12877                         qboolean applycolor = true;
12878                         float one = 1.0;
12879
12880                         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12881
12882                         r_refdef.lightmapintensity = 1;
12883                         RSurf_DrawBatch_GL11_ApplyVertexShade(&one, &one, &one, &one, &applycolor);
12884                         r_refdef.lightmapintensity = 0; // we're in showsurfaces, after all
12885                 }
12886                 else if (FAKELIGHT_ENABLED)
12887                 {
12888                         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12889
12890                         r_refdef.lightmapintensity = r_fakelight_intensity.value;
12891                         RSurf_DrawBatch_GL11_ApplyFakeLight();
12892                         r_refdef.lightmapintensity = 0; // we're in showsurfaces, after all
12893                 }
12894                 else
12895                 {
12896                         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_VERTEXCOLOR | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12897
12898                         rsurface.passcolor4f = rsurface.batchlightmapcolor4f;
12899                         rsurface.passcolor4f_vertexbuffer = rsurface.batchlightmapcolor4f_vertexbuffer;
12900                         rsurface.passcolor4f_bufferoffset = rsurface.batchlightmapcolor4f_bufferoffset;
12901                 }
12902
12903                 if(!rsurface.passcolor4f)
12904                         RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray();
12905
12906                 RSurf_DrawBatch_GL11_ApplyAmbient();
12907                 RSurf_DrawBatch_GL11_ApplyColor(c[0], c[1], c[2], c[3]);
12908                 if(r_refdef.fogenabled)
12909                         RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors();
12910                 RSurf_DrawBatch_GL11_ClampColor();
12911
12912                 R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, rsurface.passcolor4f, NULL);
12913                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
12914                 RSurf_DrawBatch();
12915         }
12916         else if (!r_refdef.view.showdebug)
12917         {
12918                 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12919                 batchvertex = R_Mesh_PrepareVertices_Generic_Lock(rsurface.batchnumvertices);
12920                 for (j = 0, vi = rsurface.batchfirstvertex;j < rsurface.batchnumvertices;j++, vi++)
12921                 {
12922                         VectorCopy(rsurface.batchvertex3f + 3*vi, batchvertex[vi].vertex3f);
12923                         Vector4Set(batchvertex[vi].color4ub, 0, 0, 0, 255);
12924                 }
12925                 R_Mesh_PrepareVertices_Generic_Unlock();
12926                 RSurf_DrawBatch();
12927         }
12928         else if (r_showsurfaces.integer == 4)
12929         {
12930                 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12931                 batchvertex = R_Mesh_PrepareVertices_Generic_Lock(rsurface.batchnumvertices);
12932                 for (j = 0, vi = rsurface.batchfirstvertex;j < rsurface.batchnumvertices;j++, vi++)
12933                 {
12934                         unsigned char c = vi << 3;
12935                         VectorCopy(rsurface.batchvertex3f + 3*vi, batchvertex[vi].vertex3f);
12936                         Vector4Set(batchvertex[vi].color4ub, c, c, c, 255);
12937                 }
12938                 R_Mesh_PrepareVertices_Generic_Unlock();
12939                 RSurf_DrawBatch();
12940         }
12941         else if (r_showsurfaces.integer == 2)
12942         {
12943                 const int *e;
12944                 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12945                 batchvertex = R_Mesh_PrepareVertices_Generic_Lock(3*rsurface.batchnumtriangles);
12946                 for (j = 0, e = rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle;j < rsurface.batchnumtriangles;j++, e += 3)
12947                 {
12948                         unsigned char c = (j + rsurface.batchfirsttriangle) << 3;
12949                         VectorCopy(rsurface.batchvertex3f + 3*e[0], batchvertex[j*3+0].vertex3f);
12950                         VectorCopy(rsurface.batchvertex3f + 3*e[1], batchvertex[j*3+1].vertex3f);
12951                         VectorCopy(rsurface.batchvertex3f + 3*e[2], batchvertex[j*3+2].vertex3f);
12952                         Vector4Set(batchvertex[j*3+0].color4ub, c, c, c, 255);
12953                         Vector4Set(batchvertex[j*3+1].color4ub, c, c, c, 255);
12954                         Vector4Set(batchvertex[j*3+2].color4ub, c, c, c, 255);
12955                 }
12956                 R_Mesh_PrepareVertices_Generic_Unlock();
12957                 R_Mesh_Draw(0, rsurface.batchnumtriangles*3, 0, rsurface.batchnumtriangles, NULL, NULL, 0, NULL, NULL, 0);
12958         }
12959         else
12960         {
12961                 int texturesurfaceindex;
12962                 int k;
12963                 const msurface_t *surface;
12964                 unsigned char surfacecolor4ub[4];
12965                 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12966                 batchvertex = R_Mesh_PrepareVertices_Generic_Lock(rsurface.batchfirstvertex + rsurface.batchnumvertices);
12967                 vi = 0;
12968                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
12969                 {
12970                         surface = texturesurfacelist[texturesurfaceindex];
12971                         k = (int)(((size_t)surface) / sizeof(msurface_t));
12972                         Vector4Set(surfacecolor4ub, (k & 0xF) << 4, (k & 0xF0), (k & 0xF00) >> 4, 255);
12973                         for (j = 0;j < surface->num_vertices;j++)
12974                         {
12975                                 VectorCopy(rsurface.batchvertex3f + 3*vi, batchvertex[vi].vertex3f);
12976                                 Vector4Copy(surfacecolor4ub, batchvertex[vi].color4ub);
12977                                 vi++;
12978                         }
12979                 }
12980                 R_Mesh_PrepareVertices_Generic_Unlock();
12981                 RSurf_DrawBatch();
12982         }
12983 }
12984
12985 static void R_DrawWorldTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
12986 {
12987         CHECKGLERROR
12988         RSurf_SetupDepthAndCulling();
12989         if (r_showsurfaces.integer)
12990         {
12991                 R_DrawTextureSurfaceList_ShowSurfaces(texturenumsurfaces, texturesurfacelist, writedepth);
12992                 return;
12993         }
12994         switch (vid.renderpath)
12995         {
12996         case RENDERPATH_GL20:
12997         case RENDERPATH_CGGL:
12998         case RENDERPATH_D3D9:
12999         case RENDERPATH_D3D10:
13000         case RENDERPATH_D3D11:
13001                 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
13002                 break;
13003         case RENDERPATH_GL13:
13004                 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
13005                 break;
13006         case RENDERPATH_GL11:
13007                 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
13008                 break;
13009         }
13010         CHECKGLERROR
13011 }
13012
13013 static void R_DrawModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
13014 {
13015         CHECKGLERROR
13016         RSurf_SetupDepthAndCulling();
13017         if (r_showsurfaces.integer)
13018         {
13019                 R_DrawTextureSurfaceList_ShowSurfaces(texturenumsurfaces, texturesurfacelist, writedepth);
13020                 return;
13021         }
13022         switch (vid.renderpath)
13023         {
13024         case RENDERPATH_GL20:
13025         case RENDERPATH_CGGL:
13026         case RENDERPATH_D3D9:
13027         case RENDERPATH_D3D10:
13028         case RENDERPATH_D3D11:
13029                 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
13030                 break;
13031         case RENDERPATH_GL13:
13032                 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
13033                 break;
13034         case RENDERPATH_GL11:
13035                 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
13036                 break;
13037         }
13038         CHECKGLERROR
13039 }
13040
13041 static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
13042 {
13043         int i, j;
13044         int texturenumsurfaces, endsurface;
13045         texture_t *texture;
13046         const msurface_t *surface;
13047 #define MAXBATCH_TRANSPARENTSURFACES 256
13048         const msurface_t *texturesurfacelist[MAXBATCH_TRANSPARENTSURFACES];
13049
13050         // if the model is static it doesn't matter what value we give for
13051         // wantnormals and wanttangents, so this logic uses only rules applicable
13052         // to a model, knowing that they are meaningless otherwise
13053         if (ent == r_refdef.scene.worldentity)
13054                 RSurf_ActiveWorldEntity();
13055         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
13056                 RSurf_ActiveModelEntity(ent, false, false, false);
13057         else
13058         {
13059                 switch (vid.renderpath)
13060                 {
13061                 case RENDERPATH_GL20:
13062                 case RENDERPATH_CGGL:
13063                 case RENDERPATH_D3D9:
13064                 case RENDERPATH_D3D10:
13065                 case RENDERPATH_D3D11:
13066                         RSurf_ActiveModelEntity(ent, true, true, false);
13067                         break;
13068                 case RENDERPATH_GL13:
13069                 case RENDERPATH_GL11:
13070                         RSurf_ActiveModelEntity(ent, true, false, false);
13071                         break;
13072                 }
13073         }
13074
13075         if (r_transparentdepthmasking.integer)
13076         {
13077                 qboolean setup = false;
13078                 for (i = 0;i < numsurfaces;i = j)
13079                 {
13080                         j = i + 1;
13081                         surface = rsurface.modelsurfaces + surfacelist[i];
13082                         texture = surface->texture;
13083                         rsurface.texture = R_GetCurrentTexture(texture);
13084                         rsurface.lightmaptexture = NULL;
13085                         rsurface.deluxemaptexture = NULL;
13086                         rsurface.uselightmaptexture = false;
13087                         // scan ahead until we find a different texture
13088                         endsurface = min(i + 1024, numsurfaces);
13089                         texturenumsurfaces = 0;
13090                         texturesurfacelist[texturenumsurfaces++] = surface;
13091                         for (;j < endsurface;j++)
13092                         {
13093                                 surface = rsurface.modelsurfaces + surfacelist[j];
13094                                 if (texture != surface->texture)
13095                                         break;
13096                                 texturesurfacelist[texturenumsurfaces++] = surface;
13097                         }
13098                         if (!(rsurface.texture->currentmaterialflags & MATERIALFLAG_TRANSDEPTH))
13099                                 continue;
13100                         // render the range of surfaces as depth
13101                         if (!setup)
13102                         {
13103                                 setup = true;
13104                                 GL_ColorMask(0,0,0,0);
13105                                 GL_Color(1,1,1,1);
13106                                 GL_DepthTest(true);
13107                                 GL_BlendFunc(GL_ONE, GL_ZERO);
13108                                 GL_DepthMask(true);
13109                                 GL_AlphaTest(false);
13110                                 R_Mesh_ResetTextureState();
13111                                 R_SetupShader_DepthOrShadow();
13112                         }
13113                         RSurf_SetupDepthAndCulling();
13114                         RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXPOSITION, texturenumsurfaces, texturesurfacelist);
13115                         R_Mesh_PrepareVertices_Position(rsurface.batchnumvertices, rsurface.batchvertexposition, rsurface.batchvertexpositionbuffer);
13116                         RSurf_DrawBatch();
13117                 }
13118                 if (setup)
13119                         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
13120         }
13121
13122         for (i = 0;i < numsurfaces;i = j)
13123         {
13124                 j = i + 1;
13125                 surface = rsurface.modelsurfaces + surfacelist[i];
13126                 texture = surface->texture;
13127                 rsurface.texture = R_GetCurrentTexture(texture);
13128                 // scan ahead until we find a different texture
13129                 endsurface = min(i + MAXBATCH_TRANSPARENTSURFACES, numsurfaces);
13130                 texturenumsurfaces = 0;
13131                 texturesurfacelist[texturenumsurfaces++] = surface;
13132                 if(FAKELIGHT_ENABLED)
13133                 {
13134                         rsurface.lightmaptexture = NULL;
13135                         rsurface.deluxemaptexture = NULL;
13136                         rsurface.uselightmaptexture = false;
13137                         for (;j < endsurface;j++)
13138                         {
13139                                 surface = rsurface.modelsurfaces + surfacelist[j];
13140                                 if (texture != surface->texture)
13141                                         break;
13142                                 texturesurfacelist[texturenumsurfaces++] = surface;
13143                         }
13144                 }
13145                 else
13146                 {
13147                         rsurface.lightmaptexture = surface->lightmaptexture;
13148                         rsurface.deluxemaptexture = surface->deluxemaptexture;
13149                         rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
13150                         for (;j < endsurface;j++)
13151                         {
13152                                 surface = rsurface.modelsurfaces + surfacelist[j];
13153                                 if (texture != surface->texture || rsurface.lightmaptexture != surface->lightmaptexture)
13154                                         break;
13155                                 texturesurfacelist[texturenumsurfaces++] = surface;
13156                         }
13157                 }
13158                 // render the range of surfaces
13159                 if (ent == r_refdef.scene.worldentity)
13160                         R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false, false);
13161                 else
13162                         R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false, false);
13163         }
13164         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
13165         GL_AlphaTest(false);
13166 }
13167
13168 static void R_ProcessTransparentTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, const entity_render_t *queueentity)
13169 {
13170         // transparent surfaces get pushed off into the transparent queue
13171         int surfacelistindex;
13172         const msurface_t *surface;
13173         vec3_t tempcenter, center;
13174         for (surfacelistindex = 0;surfacelistindex < texturenumsurfaces;surfacelistindex++)
13175         {
13176                 surface = texturesurfacelist[surfacelistindex];
13177                 tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f;
13178                 tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f;
13179                 tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f;
13180                 Matrix4x4_Transform(&rsurface.matrix, tempcenter, center);
13181                 if (queueentity->transparent_offset) // transparent offset
13182                 {
13183                         center[0] += r_refdef.view.forward[0]*queueentity->transparent_offset;
13184                         center[1] += r_refdef.view.forward[1]*queueentity->transparent_offset;
13185                         center[2] += r_refdef.view.forward[2]*queueentity->transparent_offset;
13186                 }
13187                 R_MeshQueue_AddTransparent(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_refdef.view.origin : center, R_DrawSurface_TransparentCallback, queueentity, surface - rsurface.modelsurfaces, rsurface.rtlight);
13188         }
13189 }
13190
13191 static void R_DrawTextureSurfaceList_DepthOnly(int texturenumsurfaces, const msurface_t **texturesurfacelist)
13192 {
13193         if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
13194                 return;
13195         if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)))
13196                 return;
13197         RSurf_SetupDepthAndCulling();
13198         RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXPOSITION, texturenumsurfaces, texturesurfacelist);
13199         R_Mesh_PrepareVertices_Position(rsurface.batchnumvertices, rsurface.batchvertexposition, rsurface.batchvertexpositionbuffer);
13200         RSurf_DrawBatch();
13201 }
13202
13203 static void R_ProcessWorldTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, qboolean prepass)
13204 {
13205         const entity_render_t *queueentity = r_refdef.scene.worldentity;
13206         CHECKGLERROR
13207         if (depthonly)
13208                 R_DrawTextureSurfaceList_DepthOnly(texturenumsurfaces, texturesurfacelist);
13209         else if (prepass)
13210         {
13211                 if (!rsurface.texture->currentnumlayers)
13212                         return;
13213                 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
13214                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
13215                 else
13216                         R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
13217         }
13218         else if ((rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY) && !r_showsurfaces.integer)
13219                 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
13220         else if (!rsurface.texture->currentnumlayers)
13221                 return;
13222         else if (((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) || (r_showsurfaces.integer == 3 && (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST))) && queueentity)
13223         {
13224                 // in the deferred case, transparent surfaces were queued during prepass
13225                 if (!r_shadow_usingdeferredprepass)
13226                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
13227         }
13228         else
13229         {
13230                 // the alphatest check is to make sure we write depth for anything we skipped on the depth-only pass earlier
13231                 R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST), prepass);
13232         }
13233         CHECKGLERROR
13234 }
13235
13236 void R_QueueWorldSurfaceList(int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass)
13237 {
13238         int i, j;
13239         texture_t *texture;
13240         // break the surface list down into batches by texture and use of lightmapping
13241         for (i = 0;i < numsurfaces;i = j)
13242         {
13243                 j = i + 1;
13244                 // texture is the base texture pointer, rsurface.texture is the
13245                 // current frame/skin the texture is directing us to use (for example
13246                 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
13247                 // use skin 1 instead)
13248                 texture = surfacelist[i]->texture;
13249                 rsurface.texture = R_GetCurrentTexture(texture);
13250                 if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW))
13251                 {
13252                         // if this texture is not the kind we want, skip ahead to the next one
13253                         for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
13254                                 ;
13255                         continue;
13256                 }
13257                 if(FAKELIGHT_ENABLED || depthonly || prepass)
13258                 {
13259                         rsurface.lightmaptexture = NULL;
13260                         rsurface.deluxemaptexture = NULL;
13261                         rsurface.uselightmaptexture = false;
13262                         // simply scan ahead until we find a different texture or lightmap state
13263                         for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
13264                                 ;
13265                 }
13266                 else
13267                 {
13268                         rsurface.lightmaptexture = surfacelist[i]->lightmaptexture;
13269                         rsurface.deluxemaptexture = surfacelist[i]->deluxemaptexture;
13270                         rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL;
13271                         // simply scan ahead until we find a different texture or lightmap state
13272                         for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.lightmaptexture == surfacelist[j]->lightmaptexture;j++)
13273                                 ;
13274                 }
13275                 // render the range of surfaces
13276                 R_ProcessWorldTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, prepass);
13277         }
13278 }
13279
13280 static void R_ProcessModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, const entity_render_t *queueentity, qboolean prepass)
13281 {
13282         CHECKGLERROR
13283         if (depthonly)
13284                 R_DrawTextureSurfaceList_DepthOnly(texturenumsurfaces, texturesurfacelist);
13285         else if (prepass)
13286         {
13287                 if (!rsurface.texture->currentnumlayers)
13288                         return;
13289                 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
13290                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
13291                 else
13292                         R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
13293         }
13294         else if ((rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY) && !r_showsurfaces.integer)
13295                 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
13296         else if (!rsurface.texture->currentnumlayers)
13297                 return;
13298         else if (((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) || (r_showsurfaces.integer == 3 && (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST))) && queueentity)
13299         {
13300                 // in the deferred case, transparent surfaces were queued during prepass
13301                 if (!r_shadow_usingdeferredprepass)
13302                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
13303         }
13304         else
13305         {
13306                 // the alphatest check is to make sure we write depth for anything we skipped on the depth-only pass earlier
13307                 R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST), prepass);
13308         }
13309         CHECKGLERROR
13310 }
13311
13312 void R_QueueModelSurfaceList(entity_render_t *ent, int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass)
13313 {
13314         int i, j;
13315         texture_t *texture;
13316         // break the surface list down into batches by texture and use of lightmapping
13317         for (i = 0;i < numsurfaces;i = j)
13318         {
13319                 j = i + 1;
13320                 // texture is the base texture pointer, rsurface.texture is the
13321                 // current frame/skin the texture is directing us to use (for example
13322                 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
13323                 // use skin 1 instead)
13324                 texture = surfacelist[i]->texture;
13325                 rsurface.texture = R_GetCurrentTexture(texture);
13326                 if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW))
13327                 {
13328                         // if this texture is not the kind we want, skip ahead to the next one
13329                         for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
13330                                 ;
13331                         continue;
13332                 }
13333                 if(FAKELIGHT_ENABLED || depthonly || prepass)
13334                 {
13335                         rsurface.lightmaptexture = NULL;
13336                         rsurface.deluxemaptexture = NULL;
13337                         rsurface.uselightmaptexture = false;
13338                         // simply scan ahead until we find a different texture or lightmap state
13339                         for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
13340                                 ;
13341                 }
13342                 else
13343                 {
13344                         rsurface.lightmaptexture = surfacelist[i]->lightmaptexture;
13345                         rsurface.deluxemaptexture = surfacelist[i]->deluxemaptexture;
13346                         rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL;
13347                         // simply scan ahead until we find a different texture or lightmap state
13348                         for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.lightmaptexture == surfacelist[j]->lightmaptexture;j++)
13349                                 ;
13350                 }
13351                 // render the range of surfaces
13352                 R_ProcessModelTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, ent, prepass);
13353         }
13354 }
13355
13356 float locboxvertex3f[6*4*3] =
13357 {
13358         1,0,1, 1,0,0, 1,1,0, 1,1,1,
13359         0,1,1, 0,1,0, 0,0,0, 0,0,1,
13360         1,1,1, 1,1,0, 0,1,0, 0,1,1,
13361         0,0,1, 0,0,0, 1,0,0, 1,0,1,
13362         0,0,1, 1,0,1, 1,1,1, 0,1,1,
13363         1,0,0, 0,0,0, 0,1,0, 1,1,0
13364 };
13365
13366 unsigned short locboxelements[6*2*3] =
13367 {
13368          0, 1, 2, 0, 2, 3,
13369          4, 5, 6, 4, 6, 7,
13370          8, 9,10, 8,10,11,
13371         12,13,14, 12,14,15,
13372         16,17,18, 16,18,19,
13373         20,21,22, 20,22,23
13374 };
13375
13376 void R_DrawLoc_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
13377 {
13378         int i, j;
13379         cl_locnode_t *loc = (cl_locnode_t *)ent;
13380         vec3_t mins, size;
13381         float vertex3f[6*4*3];
13382         CHECKGLERROR
13383         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
13384         GL_DepthMask(false);
13385         GL_DepthRange(0, 1);
13386         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
13387         GL_DepthTest(true);
13388         GL_CullFace(GL_NONE);
13389         R_EntityMatrix(&identitymatrix);
13390
13391         R_Mesh_ResetTextureState();
13392
13393         i = surfacelist[0];
13394         GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f) * r_refdef.view.colorscale,
13395                          ((i & 0x0038) >> 3) * (1.0f / 7.0f) * r_refdef.view.colorscale,
13396                          ((i & 0x01C0) >> 6) * (1.0f / 7.0f) * r_refdef.view.colorscale,
13397                         surfacelist[0] < 0 ? 0.5f : 0.125f);
13398
13399         if (VectorCompare(loc->mins, loc->maxs))
13400         {
13401                 VectorSet(size, 2, 2, 2);
13402                 VectorMA(loc->mins, -0.5f, size, mins);
13403         }
13404         else
13405         {
13406                 VectorCopy(loc->mins, mins);
13407                 VectorSubtract(loc->maxs, loc->mins, size);
13408         }
13409
13410         for (i = 0;i < 6*4*3;)
13411                 for (j = 0;j < 3;j++, i++)
13412                         vertex3f[i] = mins[j] + size[j] * locboxvertex3f[i];
13413
13414         R_Mesh_PrepareVertices_Generic_Arrays(6*4, vertex3f, NULL, NULL);
13415         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
13416         R_Mesh_Draw(0, 6*4, 0, 6*2, NULL, NULL, 0, locboxelements, NULL, 0);
13417 }
13418
13419 void R_DrawLocs(void)
13420 {
13421         int index;
13422         cl_locnode_t *loc, *nearestloc;
13423         vec3_t center;
13424         nearestloc = CL_Locs_FindNearest(cl.movement_origin);
13425         for (loc = cl.locnodes, index = 0;loc;loc = loc->next, index++)
13426         {
13427                 VectorLerp(loc->mins, 0.5f, loc->maxs, center);
13428                 R_MeshQueue_AddTransparent(center, R_DrawLoc_Callback, (entity_render_t *)loc, loc == nearestloc ? -1 : index, NULL);
13429         }
13430 }
13431
13432 void R_DecalSystem_Reset(decalsystem_t *decalsystem)
13433 {
13434         if (decalsystem->decals)
13435                 Mem_Free(decalsystem->decals);
13436         memset(decalsystem, 0, sizeof(*decalsystem));
13437 }
13438
13439 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)
13440 {
13441         tridecal_t *decal;
13442         tridecal_t *decals;
13443         int i;
13444
13445         // expand or initialize the system
13446         if (decalsystem->maxdecals <= decalsystem->numdecals)
13447         {
13448                 decalsystem_t old = *decalsystem;
13449                 qboolean useshortelements;
13450                 decalsystem->maxdecals = max(16, decalsystem->maxdecals * 2);
13451                 useshortelements = decalsystem->maxdecals * 3 <= 65536;
13452                 decalsystem->decals = (tridecal_t *)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)));
13453                 decalsystem->color4f = (float *)(decalsystem->decals + decalsystem->maxdecals);
13454                 decalsystem->texcoord2f = (float *)(decalsystem->color4f + decalsystem->maxdecals*12);
13455                 decalsystem->vertex3f = (float *)(decalsystem->texcoord2f + decalsystem->maxdecals*6);
13456                 decalsystem->element3i = (int *)(decalsystem->vertex3f + decalsystem->maxdecals*9);
13457                 decalsystem->element3s = (useshortelements ? ((unsigned short *)(decalsystem->element3i + decalsystem->maxdecals*3)) : NULL);
13458                 if (decalsystem->numdecals)
13459                         memcpy(decalsystem->decals, old.decals, decalsystem->numdecals * sizeof(tridecal_t));
13460                 if (old.decals)
13461                         Mem_Free(old.decals);
13462                 for (i = 0;i < decalsystem->maxdecals*3;i++)
13463                         decalsystem->element3i[i] = i;
13464                 if (useshortelements)
13465                         for (i = 0;i < decalsystem->maxdecals*3;i++)
13466                                 decalsystem->element3s[i] = i;
13467         }
13468
13469         // grab a decal and search for another free slot for the next one
13470         decals = decalsystem->decals;
13471         decal = decalsystem->decals + (i = decalsystem->freedecal++);
13472         for (i = decalsystem->freedecal;i < decalsystem->numdecals && decals[i].color4ub[0][3];i++)
13473                 ;
13474         decalsystem->freedecal = i;
13475         if (decalsystem->numdecals <= i)
13476                 decalsystem->numdecals = i + 1;
13477
13478         // initialize the decal
13479         decal->lived = 0;
13480         decal->triangleindex = triangleindex;
13481         decal->surfaceindex = surfaceindex;
13482         decal->decalsequence = decalsequence;
13483         decal->color4ub[0][0] = (unsigned char)(c0[0]*255.0f);
13484         decal->color4ub[0][1] = (unsigned char)(c0[1]*255.0f);
13485         decal->color4ub[0][2] = (unsigned char)(c0[2]*255.0f);
13486         decal->color4ub[0][3] = 255;
13487         decal->color4ub[1][0] = (unsigned char)(c1[0]*255.0f);
13488         decal->color4ub[1][1] = (unsigned char)(c1[1]*255.0f);
13489         decal->color4ub[1][2] = (unsigned char)(c1[2]*255.0f);
13490         decal->color4ub[1][3] = 255;
13491         decal->color4ub[2][0] = (unsigned char)(c2[0]*255.0f);
13492         decal->color4ub[2][1] = (unsigned char)(c2[1]*255.0f);
13493         decal->color4ub[2][2] = (unsigned char)(c2[2]*255.0f);
13494         decal->color4ub[2][3] = 255;
13495         decal->vertex3f[0][0] = v0[0];
13496         decal->vertex3f[0][1] = v0[1];
13497         decal->vertex3f[0][2] = v0[2];
13498         decal->vertex3f[1][0] = v1[0];
13499         decal->vertex3f[1][1] = v1[1];
13500         decal->vertex3f[1][2] = v1[2];
13501         decal->vertex3f[2][0] = v2[0];
13502         decal->vertex3f[2][1] = v2[1];
13503         decal->vertex3f[2][2] = v2[2];
13504         decal->texcoord2f[0][0] = t0[0];
13505         decal->texcoord2f[0][1] = t0[1];
13506         decal->texcoord2f[1][0] = t1[0];
13507         decal->texcoord2f[1][1] = t1[1];
13508         decal->texcoord2f[2][0] = t2[0];
13509         decal->texcoord2f[2][1] = t2[1];
13510 }
13511
13512 extern cvar_t cl_decals_bias;
13513 extern cvar_t cl_decals_models;
13514 extern cvar_t cl_decals_newsystem_intensitymultiplier;
13515 // baseparms, parms, temps
13516 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)
13517 {
13518         int cornerindex;
13519         int index;
13520         float v[9][3];
13521         const float *vertex3f;
13522         int numpoints;
13523         float points[2][9][3];
13524         float temp[3];
13525         float tc[9][2];
13526         float f;
13527         float c[9][4];
13528         const int *e;
13529
13530         e = rsurface.modelelement3i + 3*triangleindex;
13531
13532         vertex3f = rsurface.modelvertex3f;
13533
13534         for (cornerindex = 0;cornerindex < 3;cornerindex++)
13535         {
13536                 index = 3*e[cornerindex];
13537                 VectorCopy(vertex3f + index, v[cornerindex]);
13538         }
13539         // cull backfaces
13540         //TriangleNormal(v[0], v[1], v[2], normal);
13541         //if (DotProduct(normal, localnormal) < 0.0f)
13542         //      continue;
13543         // clip by each of the box planes formed from the projection matrix
13544         // if anything survives, we emit the decal
13545         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]);
13546         if (numpoints < 3)
13547                 return;
13548         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]);
13549         if (numpoints < 3)
13550                 return;
13551         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]);
13552         if (numpoints < 3)
13553                 return;
13554         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]);
13555         if (numpoints < 3)
13556                 return;
13557         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]);
13558         if (numpoints < 3)
13559                 return;
13560         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]);
13561         if (numpoints < 3)
13562                 return;
13563         // some part of the triangle survived, so we have to accept it...
13564         if (dynamic)
13565         {
13566                 // dynamic always uses the original triangle
13567                 numpoints = 3;
13568                 for (cornerindex = 0;cornerindex < 3;cornerindex++)
13569                 {
13570                         index = 3*e[cornerindex];
13571                         VectorCopy(vertex3f + index, v[cornerindex]);
13572                 }
13573         }
13574         for (cornerindex = 0;cornerindex < numpoints;cornerindex++)
13575         {
13576                 // convert vertex positions to texcoords
13577                 Matrix4x4_Transform(projection, v[cornerindex], temp);
13578                 tc[cornerindex][0] = (temp[1]+1.0f)*0.5f * (s2-s1) + s1;
13579                 tc[cornerindex][1] = (temp[2]+1.0f)*0.5f * (t2-t1) + t1;
13580                 // calculate distance fade from the projection origin
13581                 f = a * (1.0f-fabs(temp[0])) * cl_decals_newsystem_intensitymultiplier.value;
13582                 f = bound(0.0f, f, 1.0f);
13583                 c[cornerindex][0] = r * f;
13584                 c[cornerindex][1] = g * f;
13585                 c[cornerindex][2] = b * f;
13586                 c[cornerindex][3] = 1.0f;
13587                 //VectorMA(v[cornerindex], cl_decals_bias.value, localnormal, v[cornerindex]);
13588         }
13589         if (dynamic)
13590                 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);
13591         else
13592                 for (cornerindex = 0;cornerindex < numpoints-2;cornerindex++)
13593                         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);
13594 }
13595 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)
13596 {
13597         matrix4x4_t projection;
13598         decalsystem_t *decalsystem;
13599         qboolean dynamic;
13600         dp_model_t *model;
13601         const msurface_t *surface;
13602         const msurface_t *surfaces;
13603         const int *surfacelist;
13604         const texture_t *texture;
13605         int numtriangles;
13606         int numsurfacelist;
13607         int surfacelistindex;
13608         int surfaceindex;
13609         int triangleindex;
13610         float localorigin[3];
13611         float localnormal[3];
13612         float localmins[3];
13613         float localmaxs[3];
13614         float localsize;
13615         //float normal[3];
13616         float planes[6][4];
13617         float angles[3];
13618         bih_t *bih;
13619         int bih_triangles_count;
13620         int bih_triangles[256];
13621         int bih_surfaces[256];
13622
13623         decalsystem = &ent->decalsystem;
13624         model = ent->model;
13625         if (!model || !ent->allowdecals || ent->alpha < 1 || (ent->flags & (RENDER_ADDITIVE | RENDER_NODEPTHTEST)))
13626         {
13627                 R_DecalSystem_Reset(&ent->decalsystem);
13628                 return;
13629         }
13630
13631         if (!model->brush.data_leafs && !cl_decals_models.integer)
13632         {
13633                 if (decalsystem->model)
13634                         R_DecalSystem_Reset(decalsystem);
13635                 return;
13636         }
13637
13638         if (decalsystem->model != model)
13639                 R_DecalSystem_Reset(decalsystem);
13640         decalsystem->model = model;
13641
13642         RSurf_ActiveModelEntity(ent, false, false, false);
13643
13644         Matrix4x4_Transform(&rsurface.inversematrix, worldorigin, localorigin);
13645         Matrix4x4_Transform3x3(&rsurface.inversematrix, worldnormal, localnormal);
13646         VectorNormalize(localnormal);
13647         localsize = worldsize*rsurface.inversematrixscale;
13648         localmins[0] = localorigin[0] - localsize;
13649         localmins[1] = localorigin[1] - localsize;
13650         localmins[2] = localorigin[2] - localsize;
13651         localmaxs[0] = localorigin[0] + localsize;
13652         localmaxs[1] = localorigin[1] + localsize;
13653         localmaxs[2] = localorigin[2] + localsize;
13654
13655         //VectorCopy(localnormal, planes[4]);
13656         //VectorVectors(planes[4], planes[2], planes[0]);
13657         AnglesFromVectors(angles, localnormal, NULL, false);
13658         AngleVectors(angles, planes[0], planes[2], planes[4]);
13659         VectorNegate(planes[0], planes[1]);
13660         VectorNegate(planes[2], planes[3]);
13661         VectorNegate(planes[4], planes[5]);
13662         planes[0][3] = DotProduct(planes[0], localorigin) - localsize;
13663         planes[1][3] = DotProduct(planes[1], localorigin) - localsize;
13664         planes[2][3] = DotProduct(planes[2], localorigin) - localsize;
13665         planes[3][3] = DotProduct(planes[3], localorigin) - localsize;
13666         planes[4][3] = DotProduct(planes[4], localorigin) - localsize;
13667         planes[5][3] = DotProduct(planes[5], localorigin) - localsize;
13668
13669 #if 1
13670 // works
13671 {
13672         matrix4x4_t forwardprojection;
13673         Matrix4x4_CreateFromQuakeEntity(&forwardprojection, localorigin[0], localorigin[1], localorigin[2], angles[0], angles[1], angles[2], localsize);
13674         Matrix4x4_Invert_Simple(&projection, &forwardprojection);
13675 }
13676 #else
13677 // broken
13678 {
13679         float projectionvector[4][3];
13680         VectorScale(planes[0], ilocalsize, projectionvector[0]);
13681         VectorScale(planes[2], ilocalsize, projectionvector[1]);
13682         VectorScale(planes[4], ilocalsize, projectionvector[2]);
13683         projectionvector[0][0] = planes[0][0] * ilocalsize;
13684         projectionvector[0][1] = planes[1][0] * ilocalsize;
13685         projectionvector[0][2] = planes[2][0] * ilocalsize;
13686         projectionvector[1][0] = planes[0][1] * ilocalsize;
13687         projectionvector[1][1] = planes[1][1] * ilocalsize;
13688         projectionvector[1][2] = planes[2][1] * ilocalsize;
13689         projectionvector[2][0] = planes[0][2] * ilocalsize;
13690         projectionvector[2][1] = planes[1][2] * ilocalsize;
13691         projectionvector[2][2] = planes[2][2] * ilocalsize;
13692         projectionvector[3][0] = -(localorigin[0]*projectionvector[0][0]+localorigin[1]*projectionvector[1][0]+localorigin[2]*projectionvector[2][0]);
13693         projectionvector[3][1] = -(localorigin[0]*projectionvector[0][1]+localorigin[1]*projectionvector[1][1]+localorigin[2]*projectionvector[2][1]);
13694         projectionvector[3][2] = -(localorigin[0]*projectionvector[0][2]+localorigin[1]*projectionvector[1][2]+localorigin[2]*projectionvector[2][2]);
13695         Matrix4x4_FromVectors(&projection, projectionvector[0], projectionvector[1], projectionvector[2], projectionvector[3]);
13696 }
13697 #endif
13698
13699         dynamic = model->surfmesh.isanimated;
13700         numsurfacelist = model->nummodelsurfaces;
13701         surfacelist = model->sortedmodelsurfaces;
13702         surfaces = model->data_surfaces;
13703
13704         bih = NULL;
13705         bih_triangles_count = -1;
13706         if(!dynamic)
13707         {
13708                 if(model->render_bih.numleafs)
13709                         bih = &model->render_bih;
13710                 else if(model->collision_bih.numleafs)
13711                         bih = &model->collision_bih;
13712         }
13713         if(bih)
13714                 bih_triangles_count = BIH_GetTriangleListForBox(bih, sizeof(bih_triangles) / sizeof(*bih_triangles), bih_triangles, bih_surfaces, localmins, localmaxs);
13715         if(bih_triangles_count == 0)
13716                 return;
13717         if(bih_triangles_count > (int) (sizeof(bih_triangles) / sizeof(*bih_triangles))) // hit too many, likely bad anyway
13718                 return;
13719         if(bih_triangles_count > 0)
13720         {
13721                 for (triangleindex = 0; triangleindex < bih_triangles_count; ++triangleindex)
13722                 {
13723                         surfaceindex = bih_surfaces[triangleindex];
13724                         surface = surfaces + surfaceindex;
13725                         texture = surface->texture;
13726                         if (texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SKY | MATERIALFLAG_SHORTDEPTHRANGE | MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
13727                                 continue;
13728                         if (texture->surfaceflags & Q3SURFACEFLAG_NOMARKS)
13729                                 continue;
13730                         R_DecalSystem_SplatTriangle(decalsystem, r, g, b, a, s1, t1, s2, t2, decalsequence, dynamic, planes, &projection, bih_triangles[triangleindex], surfaceindex);
13731                 }
13732         }
13733         else
13734         {
13735                 for (surfacelistindex = 0;surfacelistindex < numsurfacelist;surfacelistindex++)
13736                 {
13737                         surfaceindex = surfacelist[surfacelistindex];
13738                         surface = surfaces + surfaceindex;
13739                         // check cull box first because it rejects more than any other check
13740                         if (!dynamic && !BoxesOverlap(surface->mins, surface->maxs, localmins, localmaxs))
13741                                 continue;
13742                         // skip transparent surfaces
13743                         texture = surface->texture;
13744                         if (texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SKY | MATERIALFLAG_SHORTDEPTHRANGE | MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
13745                                 continue;
13746                         if (texture->surfaceflags & Q3SURFACEFLAG_NOMARKS)
13747                                 continue;
13748                         numtriangles = surface->num_triangles;
13749                         for (triangleindex = 0; triangleindex < numtriangles; triangleindex++)
13750                                 R_DecalSystem_SplatTriangle(decalsystem, r, g, b, a, s1, t1, s2, t2, decalsequence, dynamic, planes, &projection, triangleindex + surface->num_firsttriangle, surfaceindex);
13751                 }
13752         }
13753 }
13754
13755 // do not call this outside of rendering code - use R_DecalSystem_SplatEntities instead
13756 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)
13757 {
13758         int renderentityindex;
13759         float worldmins[3];
13760         float worldmaxs[3];
13761         entity_render_t *ent;
13762
13763         if (!cl_decals_newsystem.integer)
13764                 return;
13765
13766         worldmins[0] = worldorigin[0] - worldsize;
13767         worldmins[1] = worldorigin[1] - worldsize;
13768         worldmins[2] = worldorigin[2] - worldsize;
13769         worldmaxs[0] = worldorigin[0] + worldsize;
13770         worldmaxs[1] = worldorigin[1] + worldsize;
13771         worldmaxs[2] = worldorigin[2] + worldsize;
13772
13773         R_DecalSystem_SplatEntity(r_refdef.scene.worldentity, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence);
13774
13775         for (renderentityindex = 0;renderentityindex < r_refdef.scene.numentities;renderentityindex++)
13776         {
13777                 ent = r_refdef.scene.entities[renderentityindex];
13778                 if (!BoxesOverlap(ent->mins, ent->maxs, worldmins, worldmaxs))
13779                         continue;
13780
13781                 R_DecalSystem_SplatEntity(ent, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence);
13782         }
13783 }
13784
13785 typedef struct r_decalsystem_splatqueue_s
13786 {
13787         vec3_t worldorigin;
13788         vec3_t worldnormal;
13789         float color[4];
13790         float tcrange[4];
13791         float worldsize;
13792         int decalsequence;
13793 }
13794 r_decalsystem_splatqueue_t;
13795
13796 int r_decalsystem_numqueued = 0;
13797 r_decalsystem_splatqueue_t r_decalsystem_queue[MAX_DECALSYSTEM_QUEUE];
13798
13799 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)
13800 {
13801         r_decalsystem_splatqueue_t *queue;
13802
13803         if (!cl_decals_newsystem.integer || r_decalsystem_numqueued == MAX_DECALSYSTEM_QUEUE)
13804                 return;
13805
13806         queue = &r_decalsystem_queue[r_decalsystem_numqueued++];
13807         VectorCopy(worldorigin, queue->worldorigin);
13808         VectorCopy(worldnormal, queue->worldnormal);
13809         Vector4Set(queue->color, r, g, b, a);
13810         Vector4Set(queue->tcrange, s1, t1, s2, t2);
13811         queue->worldsize = worldsize;
13812         queue->decalsequence = cl.decalsequence++;
13813 }
13814
13815 static void R_DecalSystem_ApplySplatEntitiesQueue(void)
13816 {
13817         int i;
13818         r_decalsystem_splatqueue_t *queue;
13819
13820         for (i = 0, queue = r_decalsystem_queue;i < r_decalsystem_numqueued;i++, queue++)
13821                 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);
13822         r_decalsystem_numqueued = 0;
13823 }
13824
13825 extern cvar_t cl_decals_max;
13826 static void R_DrawModelDecals_FadeEntity(entity_render_t *ent)
13827 {
13828         int i;
13829         decalsystem_t *decalsystem = &ent->decalsystem;
13830         int numdecals;
13831         int killsequence;
13832         tridecal_t *decal;
13833         float frametime;
13834         float lifetime;
13835
13836         if (!decalsystem->numdecals)
13837                 return;
13838
13839         if (r_showsurfaces.integer)
13840                 return;
13841
13842         if (ent->model != decalsystem->model || ent->alpha < 1 || (ent->flags & RENDER_ADDITIVE))
13843         {
13844                 R_DecalSystem_Reset(decalsystem);
13845                 return;
13846         }
13847
13848         killsequence = cl.decalsequence - max(1, cl_decals_max.integer);
13849         lifetime = cl_decals_time.value + cl_decals_fadetime.value;
13850
13851         if (decalsystem->lastupdatetime)
13852                 frametime = (cl.time - decalsystem->lastupdatetime);
13853         else
13854                 frametime = 0;
13855         decalsystem->lastupdatetime = cl.time;
13856         decal = decalsystem->decals;
13857         numdecals = decalsystem->numdecals;
13858
13859         for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++)
13860         {
13861                 if (decal->color4ub[0][3])
13862                 {
13863                         decal->lived += frametime;
13864                         if (killsequence - decal->decalsequence > 0 || decal->lived >= lifetime)
13865                         {
13866                                 memset(decal, 0, sizeof(*decal));
13867                                 if (decalsystem->freedecal > i)
13868                                         decalsystem->freedecal = i;
13869                         }
13870                 }
13871         }
13872         decal = decalsystem->decals;
13873         while (numdecals > 0 && !decal[numdecals-1].color4ub[0][3])
13874                 numdecals--;
13875
13876         // collapse the array by shuffling the tail decals into the gaps
13877         for (;;)
13878         {
13879                 while (decalsystem->freedecal < numdecals && decal[decalsystem->freedecal].color4ub[0][3])
13880                         decalsystem->freedecal++;
13881                 if (decalsystem->freedecal == numdecals)
13882                         break;
13883                 decal[decalsystem->freedecal] = decal[--numdecals];
13884         }
13885
13886         decalsystem->numdecals = numdecals;
13887
13888         if (numdecals <= 0)
13889         {
13890                 // if there are no decals left, reset decalsystem
13891                 R_DecalSystem_Reset(decalsystem);
13892         }
13893 }
13894
13895 extern skinframe_t *decalskinframe;
13896 static void R_DrawModelDecals_Entity(entity_render_t *ent)
13897 {
13898         int i;
13899         decalsystem_t *decalsystem = &ent->decalsystem;
13900         int numdecals;
13901         tridecal_t *decal;
13902         float faderate;
13903         float alpha;
13904         float *v3f;
13905         float *c4f;
13906         float *t2f;
13907         const int *e;
13908         const unsigned char *surfacevisible = ent == r_refdef.scene.worldentity ? r_refdef.viewcache.world_surfacevisible : NULL;
13909         int numtris = 0;
13910
13911         numdecals = decalsystem->numdecals;
13912         if (!numdecals)
13913                 return;
13914
13915         if (r_showsurfaces.integer)
13916                 return;
13917
13918         if (ent->model != decalsystem->model || ent->alpha < 1 || (ent->flags & RENDER_ADDITIVE))
13919         {
13920                 R_DecalSystem_Reset(decalsystem);
13921                 return;
13922         }
13923
13924         // if the model is static it doesn't matter what value we give for
13925         // wantnormals and wanttangents, so this logic uses only rules applicable
13926         // to a model, knowing that they are meaningless otherwise
13927         if (ent == r_refdef.scene.worldentity)
13928                 RSurf_ActiveWorldEntity();
13929         else
13930                 RSurf_ActiveModelEntity(ent, false, false, false);
13931
13932         decalsystem->lastupdatetime = cl.time;
13933         decal = decalsystem->decals;
13934
13935         faderate = 1.0f / max(0.001f, cl_decals_fadetime.value);
13936
13937         // update vertex positions for animated models
13938         v3f = decalsystem->vertex3f;
13939         c4f = decalsystem->color4f;
13940         t2f = decalsystem->texcoord2f;
13941         for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++)
13942         {
13943                 if (!decal->color4ub[0][3])
13944                         continue;
13945
13946                 if (surfacevisible && !surfacevisible[decal->surfaceindex])
13947                         continue;
13948
13949                 // update color values for fading decals
13950                 if (decal->lived >= cl_decals_time.value)
13951                 {
13952                         alpha = 1 - faderate * (decal->lived - cl_decals_time.value);
13953                         alpha *= (1.0f/255.0f);
13954                 }
13955                 else
13956                         alpha = 1.0f/255.0f;
13957
13958                 c4f[ 0] = decal->color4ub[0][0] * alpha;
13959                 c4f[ 1] = decal->color4ub[0][1] * alpha;
13960                 c4f[ 2] = decal->color4ub[0][2] * alpha;
13961                 c4f[ 3] = 1;
13962                 c4f[ 4] = decal->color4ub[1][0] * alpha;
13963                 c4f[ 5] = decal->color4ub[1][1] * alpha;
13964                 c4f[ 6] = decal->color4ub[1][2] * alpha;
13965                 c4f[ 7] = 1;
13966                 c4f[ 8] = decal->color4ub[2][0] * alpha;
13967                 c4f[ 9] = decal->color4ub[2][1] * alpha;
13968                 c4f[10] = decal->color4ub[2][2] * alpha;
13969                 c4f[11] = 1;
13970
13971                 t2f[0] = decal->texcoord2f[0][0];
13972                 t2f[1] = decal->texcoord2f[0][1];
13973                 t2f[2] = decal->texcoord2f[1][0];
13974                 t2f[3] = decal->texcoord2f[1][1];
13975                 t2f[4] = decal->texcoord2f[2][0];
13976                 t2f[5] = decal->texcoord2f[2][1];
13977
13978                 // update vertex positions for animated models
13979                 if (decal->triangleindex >= 0 && decal->triangleindex < rsurface.modelnumtriangles)
13980                 {
13981                         e = rsurface.modelelement3i + 3*decal->triangleindex;
13982                         VectorCopy(rsurface.modelvertexposition[e[0]].vertex3f, v3f);
13983                         VectorCopy(rsurface.modelvertexposition[e[1]].vertex3f, v3f + 3);
13984                         VectorCopy(rsurface.modelvertexposition[e[2]].vertex3f, v3f + 6);
13985                 }
13986                 else
13987                 {
13988                         VectorCopy(decal->vertex3f[0], v3f);
13989                         VectorCopy(decal->vertex3f[1], v3f + 3);
13990                         VectorCopy(decal->vertex3f[2], v3f + 6);
13991                 }
13992
13993                 if (r_refdef.fogenabled)
13994                 {
13995                         alpha = RSurf_FogVertex(v3f);
13996                         VectorScale(c4f, alpha, c4f);
13997                         alpha = RSurf_FogVertex(v3f + 3);
13998                         VectorScale(c4f + 4, alpha, c4f + 4);
13999                         alpha = RSurf_FogVertex(v3f + 6);
14000                         VectorScale(c4f + 8, alpha, c4f + 8);
14001                 }
14002
14003                 v3f += 9;
14004                 c4f += 12;
14005                 t2f += 6;
14006                 numtris++;
14007         }
14008
14009         if (numtris > 0)
14010         {
14011                 r_refdef.stats.drawndecals += numtris;
14012
14013                 // now render the decals all at once
14014                 // (this assumes they all use one particle font texture!)
14015                 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);
14016                 R_Mesh_ResetTextureState();
14017                 R_Mesh_PrepareVertices_Generic_Arrays(numtris * 3, decalsystem->vertex3f, decalsystem->color4f, decalsystem->texcoord2f);
14018                 GL_DepthMask(false);
14019                 GL_DepthRange(0, 1);
14020                 GL_PolygonOffset(rsurface.basepolygonfactor + r_polygonoffset_decals_factor.value, rsurface.basepolygonoffset + r_polygonoffset_decals_offset.value);
14021                 GL_DepthTest(true);
14022                 GL_CullFace(GL_NONE);
14023                 GL_BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
14024                 R_SetupShader_Generic(decalskinframe->base, NULL, GL_MODULATE, 1);
14025                 R_Mesh_Draw(0, numtris * 3, 0, numtris, decalsystem->element3i, NULL, 0, decalsystem->element3s, NULL, 0);
14026         }
14027 }
14028
14029 static void R_DrawModelDecals(void)
14030 {
14031         int i, numdecals;
14032
14033         // fade faster when there are too many decals
14034         numdecals = r_refdef.scene.worldentity->decalsystem.numdecals;
14035         for (i = 0;i < r_refdef.scene.numentities;i++)
14036                 numdecals += r_refdef.scene.entities[i]->decalsystem.numdecals;
14037
14038         R_DrawModelDecals_FadeEntity(r_refdef.scene.worldentity);
14039         for (i = 0;i < r_refdef.scene.numentities;i++)
14040                 if (r_refdef.scene.entities[i]->decalsystem.numdecals)
14041                         R_DrawModelDecals_FadeEntity(r_refdef.scene.entities[i]);
14042
14043         R_DecalSystem_ApplySplatEntitiesQueue();
14044
14045         numdecals = r_refdef.scene.worldentity->decalsystem.numdecals;
14046         for (i = 0;i < r_refdef.scene.numentities;i++)
14047                 numdecals += r_refdef.scene.entities[i]->decalsystem.numdecals;
14048
14049         r_refdef.stats.totaldecals += numdecals;
14050
14051         if (r_showsurfaces.integer)
14052                 return;
14053
14054         R_DrawModelDecals_Entity(r_refdef.scene.worldentity);
14055
14056         for (i = 0;i < r_refdef.scene.numentities;i++)
14057         {
14058                 if (!r_refdef.viewcache.entityvisible[i])
14059                         continue;
14060                 if (r_refdef.scene.entities[i]->decalsystem.numdecals)
14061                         R_DrawModelDecals_Entity(r_refdef.scene.entities[i]);
14062         }
14063 }
14064
14065 extern cvar_t mod_collision_bih;
14066 void R_DrawDebugModel(void)
14067 {
14068         entity_render_t *ent = rsurface.entity;
14069         int i, j, k, l, flagsmask;
14070         const msurface_t *surface;
14071         dp_model_t *model = ent->model;
14072         vec3_t v;
14073
14074         switch(vid.renderpath)
14075         {
14076         case RENDERPATH_GL11:
14077         case RENDERPATH_GL13:
14078         case RENDERPATH_GL20:
14079         case RENDERPATH_CGGL:
14080                 break;
14081         case RENDERPATH_D3D9:
14082                 //Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
14083                 return;
14084         case RENDERPATH_D3D10:
14085                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
14086                 return;
14087         case RENDERPATH_D3D11:
14088                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
14089                 return;
14090         }
14091
14092         flagsmask = MATERIALFLAG_SKY | MATERIALFLAG_WALL;
14093
14094         R_Mesh_ResetTextureState();
14095         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
14096         GL_DepthRange(0, 1);
14097         GL_DepthTest(!r_showdisabledepthtest.integer);
14098         GL_DepthMask(false);
14099         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
14100
14101         if (r_showcollisionbrushes.value > 0 && model->collision_bih.numleafs)
14102         {
14103                 int triangleindex;
14104                 int bihleafindex;
14105                 qboolean cullbox = ent == r_refdef.scene.worldentity;
14106                 const q3mbrush_t *brush;
14107                 const bih_t *bih = &model->collision_bih;
14108                 const bih_leaf_t *bihleaf;
14109                 float vertex3f[3][3];
14110                 GL_PolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);
14111                 cullbox = false;
14112                 for (bihleafindex = 0, bihleaf = bih->leafs;bihleafindex < bih->numleafs;bihleafindex++, bihleaf++)
14113                 {
14114                         if (cullbox && R_CullBox(bihleaf->mins, bihleaf->maxs))
14115                                 continue;
14116                         switch (bihleaf->type)
14117                         {
14118                         case BIH_BRUSH:
14119                                 brush = model->brush.data_brushes + bihleaf->itemindex;
14120                                 if (brush->colbrushf && brush->colbrushf->numtriangles)
14121                                 {
14122                                         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);
14123                                         R_Mesh_PrepareVertices_Generic_Arrays(brush->colbrushf->numpoints, brush->colbrushf->points->v, NULL, NULL);
14124                                         R_Mesh_Draw(0, brush->colbrushf->numpoints, 0, brush->colbrushf->numtriangles, brush->colbrushf->elements, NULL, 0, NULL, NULL, 0);
14125                                 }
14126                                 break;
14127                         case BIH_COLLISIONTRIANGLE:
14128                                 triangleindex = bihleaf->itemindex;
14129                                 VectorCopy(model->brush.data_collisionvertex3f + 3*model->brush.data_collisionelement3i[triangleindex*3+0], vertex3f[0]);
14130                                 VectorCopy(model->brush.data_collisionvertex3f + 3*model->brush.data_collisionelement3i[triangleindex*3+1], vertex3f[1]);
14131                                 VectorCopy(model->brush.data_collisionvertex3f + 3*model->brush.data_collisionelement3i[triangleindex*3+2], vertex3f[2]);
14132                                 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);
14133                                 R_Mesh_PrepareVertices_Generic_Arrays(3, vertex3f[0], NULL, NULL);
14134                                 R_Mesh_Draw(0, 3, 0, 1, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
14135                                 break;
14136                         case BIH_RENDERTRIANGLE:
14137                                 triangleindex = bihleaf->itemindex;
14138                                 VectorCopy(model->surfmesh.data_vertex3f + 3*model->surfmesh.data_element3i[triangleindex*3+0], vertex3f[0]);
14139                                 VectorCopy(model->surfmesh.data_vertex3f + 3*model->surfmesh.data_element3i[triangleindex*3+1], vertex3f[1]);
14140                                 VectorCopy(model->surfmesh.data_vertex3f + 3*model->surfmesh.data_element3i[triangleindex*3+2], vertex3f[2]);
14141                                 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);
14142                                 R_Mesh_PrepareVertices_Generic_Arrays(3, vertex3f[0], NULL, NULL);
14143                                 R_Mesh_Draw(0, 3, 0, 1, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
14144                                 break;
14145                         }
14146                 }
14147         }
14148
14149         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
14150
14151         if (r_showtris.integer || r_shownormals.integer)
14152         {
14153                 if (r_showdisabledepthtest.integer)
14154                 {
14155                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
14156                         GL_DepthMask(false);
14157                 }
14158                 else
14159                 {
14160                         GL_BlendFunc(GL_ONE, GL_ZERO);
14161                         GL_DepthMask(true);
14162                 }
14163                 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
14164                 {
14165                         if (ent == r_refdef.scene.worldentity && !r_refdef.viewcache.world_surfacevisible[j])
14166                                 continue;
14167                         rsurface.texture = R_GetCurrentTexture(surface->texture);
14168                         if ((rsurface.texture->currentmaterialflags & flagsmask) && surface->num_triangles)
14169                         {
14170                                 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | BATCHNEED_NOGAPS, 1, &surface);
14171                                 if (r_showtris.value > 0)
14172                                 {
14173                                         if (!rsurface.texture->currentlayers->depthmask)
14174                                                 GL_Color(r_refdef.view.colorscale, 0, 0, r_showtris.value);
14175                                         else if (ent == r_refdef.scene.worldentity)
14176                                                 GL_Color(r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale, r_showtris.value);
14177                                         else
14178                                                 GL_Color(0, r_refdef.view.colorscale, 0, r_showtris.value);
14179                                         R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, NULL, NULL);
14180                                         qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
14181                                         RSurf_DrawBatch();
14182                                         qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
14183                                         CHECKGLERROR
14184                                 }
14185                                 if (r_shownormals.value < 0)
14186                                 {
14187                                         qglBegin(GL_LINES);
14188                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
14189                                         {
14190                                                 VectorCopy(rsurface.batchvertex3f + l * 3, v);
14191                                                 GL_Color(r_refdef.view.colorscale, 0, 0, 1);
14192                                                 qglVertex3f(v[0], v[1], v[2]);
14193                                                 VectorMA(v, -r_shownormals.value, rsurface.batchsvector3f + l * 3, v);
14194                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
14195                                                 qglVertex3f(v[0], v[1], v[2]);
14196                                         }
14197                                         qglEnd();
14198                                         CHECKGLERROR
14199                                 }
14200                                 if (r_shownormals.value > 0 && rsurface.batchsvector3f)
14201                                 {
14202                                         qglBegin(GL_LINES);
14203                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
14204                                         {
14205                                                 VectorCopy(rsurface.batchvertex3f + l * 3, v);
14206                                                 GL_Color(r_refdef.view.colorscale, 0, 0, 1);
14207                                                 qglVertex3f(v[0], v[1], v[2]);
14208                                                 VectorMA(v, r_shownormals.value, rsurface.batchsvector3f + l * 3, v);
14209                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
14210                                                 qglVertex3f(v[0], v[1], v[2]);
14211                                         }
14212                                         qglEnd();
14213                                         CHECKGLERROR
14214                                         qglBegin(GL_LINES);
14215                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
14216                                         {
14217                                                 VectorCopy(rsurface.batchvertex3f + l * 3, v);
14218                                                 GL_Color(0, r_refdef.view.colorscale, 0, 1);
14219                                                 qglVertex3f(v[0], v[1], v[2]);
14220                                                 VectorMA(v, r_shownormals.value, rsurface.batchtvector3f + l * 3, v);
14221                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
14222                                                 qglVertex3f(v[0], v[1], v[2]);
14223                                         }
14224                                         qglEnd();
14225                                         CHECKGLERROR
14226                                         qglBegin(GL_LINES);
14227                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
14228                                         {
14229                                                 VectorCopy(rsurface.batchvertex3f + l * 3, v);
14230                                                 GL_Color(0, 0, r_refdef.view.colorscale, 1);
14231                                                 qglVertex3f(v[0], v[1], v[2]);
14232                                                 VectorMA(v, r_shownormals.value, rsurface.batchnormal3f + l * 3, v);
14233                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
14234                                                 qglVertex3f(v[0], v[1], v[2]);
14235                                         }
14236                                         qglEnd();
14237                                         CHECKGLERROR
14238                                 }
14239                         }
14240                 }
14241                 rsurface.texture = NULL;
14242         }
14243 }
14244
14245 extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
14246 int r_maxsurfacelist = 0;
14247 const msurface_t **r_surfacelist = NULL;
14248 void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass)
14249 {
14250         int i, j, endj, flagsmask;
14251         dp_model_t *model = r_refdef.scene.worldmodel;
14252         msurface_t *surfaces;
14253         unsigned char *update;
14254         int numsurfacelist = 0;
14255         if (model == NULL)
14256                 return;
14257
14258         if (r_maxsurfacelist < model->num_surfaces)
14259         {
14260                 r_maxsurfacelist = model->num_surfaces;
14261                 if (r_surfacelist)
14262                         Mem_Free((msurface_t**)r_surfacelist);
14263                 r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist));
14264         }
14265
14266         RSurf_ActiveWorldEntity();
14267
14268         surfaces = model->data_surfaces;
14269         update = model->brushq1.lightmapupdateflags;
14270
14271         // update light styles on this submodel
14272         if (!skysurfaces && !depthonly && !prepass && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
14273         {
14274                 model_brush_lightstyleinfo_t *style;
14275                 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
14276                 {
14277                         if (style->value != r_refdef.scene.lightstylevalue[style->style])
14278                         {
14279                                 int *list = style->surfacelist;
14280                                 style->value = r_refdef.scene.lightstylevalue[style->style];
14281                                 for (j = 0;j < style->numsurfaces;j++)
14282                                         update[list[j]] = true;
14283                         }
14284                 }
14285         }
14286
14287         flagsmask = skysurfaces ? MATERIALFLAG_SKY : MATERIALFLAG_WALL;
14288
14289         if (debug)
14290         {
14291                 R_DrawDebugModel();
14292                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
14293                 return;
14294         }
14295
14296         rsurface.lightmaptexture = NULL;
14297         rsurface.deluxemaptexture = NULL;
14298         rsurface.uselightmaptexture = false;
14299         rsurface.texture = NULL;
14300         rsurface.rtlight = NULL;
14301         numsurfacelist = 0;
14302         // add visible surfaces to draw list
14303         for (i = 0;i < model->nummodelsurfaces;i++)
14304         {
14305                 j = model->sortedmodelsurfaces[i];
14306                 if (r_refdef.viewcache.world_surfacevisible[j])
14307                         r_surfacelist[numsurfacelist++] = surfaces + j;
14308         }
14309         // update lightmaps if needed
14310         if (model->brushq1.firstrender)
14311         {
14312                 model->brushq1.firstrender = false;
14313                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
14314                         if (update[j])
14315                                 R_BuildLightMap(r_refdef.scene.worldentity, surfaces + j);
14316         }
14317         else if (update)
14318         {
14319                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
14320                         if (r_refdef.viewcache.world_surfacevisible[j])
14321                                 if (update[j])
14322                                         R_BuildLightMap(r_refdef.scene.worldentity, surfaces + j);
14323         }
14324         // don't do anything if there were no surfaces
14325         if (!numsurfacelist)
14326         {
14327                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
14328                 return;
14329         }
14330         R_QueueWorldSurfaceList(numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
14331         GL_AlphaTest(false);
14332
14333         // add to stats if desired
14334         if (r_speeds.integer && !skysurfaces && !depthonly)
14335         {
14336                 r_refdef.stats.world_surfaces += numsurfacelist;
14337                 for (j = 0;j < numsurfacelist;j++)
14338                         r_refdef.stats.world_triangles += r_surfacelist[j]->num_triangles;
14339         }
14340
14341         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
14342 }
14343
14344 void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass)
14345 {
14346         int i, j, endj, flagsmask;
14347         dp_model_t *model = ent->model;
14348         msurface_t *surfaces;
14349         unsigned char *update;
14350         int numsurfacelist = 0;
14351         if (model == NULL)
14352                 return;
14353
14354         if (r_maxsurfacelist < model->num_surfaces)
14355         {
14356                 r_maxsurfacelist = model->num_surfaces;
14357                 if (r_surfacelist)
14358                         Mem_Free((msurface_t **)r_surfacelist);
14359                 r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist));
14360         }
14361
14362         // if the model is static it doesn't matter what value we give for
14363         // wantnormals and wanttangents, so this logic uses only rules applicable
14364         // to a model, knowing that they are meaningless otherwise
14365         if (ent == r_refdef.scene.worldentity)
14366                 RSurf_ActiveWorldEntity();
14367         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
14368                 RSurf_ActiveModelEntity(ent, false, false, false);
14369         else if (prepass)
14370                 RSurf_ActiveModelEntity(ent, true, true, true);
14371         else if (depthonly)
14372         {
14373                 switch (vid.renderpath)
14374                 {
14375                 case RENDERPATH_GL20:
14376                 case RENDERPATH_CGGL:
14377                 case RENDERPATH_D3D9:
14378                 case RENDERPATH_D3D10:
14379                 case RENDERPATH_D3D11:
14380                         RSurf_ActiveModelEntity(ent, model->wantnormals, model->wanttangents, false);
14381                         break;
14382                 case RENDERPATH_GL13:
14383                 case RENDERPATH_GL11:
14384                         RSurf_ActiveModelEntity(ent, model->wantnormals, false, false);
14385                         break;
14386                 }
14387         }
14388         else
14389         {
14390                 switch (vid.renderpath)
14391                 {
14392                 case RENDERPATH_GL20:
14393                 case RENDERPATH_CGGL:
14394                 case RENDERPATH_D3D9:
14395                 case RENDERPATH_D3D10:
14396                 case RENDERPATH_D3D11:
14397                         RSurf_ActiveModelEntity(ent, true, true, false);
14398                         break;
14399                 case RENDERPATH_GL13:
14400                 case RENDERPATH_GL11:
14401                         RSurf_ActiveModelEntity(ent, true, false, false);
14402                         break;
14403                 }
14404         }
14405
14406         surfaces = model->data_surfaces;
14407         update = model->brushq1.lightmapupdateflags;
14408
14409         // update light styles
14410         if (!skysurfaces && !depthonly && !prepass && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
14411         {
14412                 model_brush_lightstyleinfo_t *style;
14413                 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
14414                 {
14415                         if (style->value != r_refdef.scene.lightstylevalue[style->style])
14416                         {
14417                                 int *list = style->surfacelist;
14418                                 style->value = r_refdef.scene.lightstylevalue[style->style];
14419                                 for (j = 0;j < style->numsurfaces;j++)
14420                                         update[list[j]] = true;
14421                         }
14422                 }
14423         }
14424
14425         flagsmask = skysurfaces ? MATERIALFLAG_SKY : MATERIALFLAG_WALL;
14426
14427         if (debug)
14428         {
14429                 R_DrawDebugModel();
14430                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
14431                 return;
14432         }
14433
14434         rsurface.lightmaptexture = NULL;
14435         rsurface.deluxemaptexture = NULL;
14436         rsurface.uselightmaptexture = false;
14437         rsurface.texture = NULL;
14438         rsurface.rtlight = NULL;
14439         numsurfacelist = 0;
14440         // add visible surfaces to draw list
14441         for (i = 0;i < model->nummodelsurfaces;i++)
14442                 r_surfacelist[numsurfacelist++] = surfaces + model->sortedmodelsurfaces[i];
14443         // don't do anything if there were no surfaces
14444         if (!numsurfacelist)
14445         {
14446                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
14447                 return;
14448         }
14449         // update lightmaps if needed
14450         if (update)
14451         {
14452                 int updated = 0;
14453                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
14454                 {
14455                         if (update[j])
14456                         {
14457                                 updated++;
14458                                 R_BuildLightMap(ent, surfaces + j);
14459                         }
14460                 }
14461         }
14462         if (update)
14463                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
14464                         if (update[j])
14465                                 R_BuildLightMap(ent, surfaces + j);
14466         R_QueueModelSurfaceList(ent, numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
14467         GL_AlphaTest(false);
14468
14469         // add to stats if desired
14470         if (r_speeds.integer && !skysurfaces && !depthonly)
14471         {
14472                 r_refdef.stats.entities_surfaces += numsurfacelist;
14473                 for (j = 0;j < numsurfacelist;j++)
14474                         r_refdef.stats.entities_triangles += r_surfacelist[j]->num_triangles;
14475         }
14476
14477         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
14478 }
14479
14480 void R_DrawCustomSurface(skinframe_t *skinframe, const matrix4x4_t *texmatrix, int materialflags, int firstvertex, int numvertices, int firsttriangle, int numtriangles, qboolean writedepth, qboolean prepass)
14481 {
14482         static texture_t texture;
14483         static msurface_t surface;
14484         const msurface_t *surfacelist = &surface;
14485
14486         // fake enough texture and surface state to render this geometry
14487
14488         texture.update_lastrenderframe = -1; // regenerate this texture
14489         texture.basematerialflags = materialflags | MATERIALFLAG_CUSTOMSURFACE | MATERIALFLAG_WALL;
14490         texture.currentskinframe = skinframe;
14491         texture.currenttexmatrix = *texmatrix; // requires MATERIALFLAG_CUSTOMSURFACE
14492         texture.offsetmapping = OFFSETMAPPING_OFF;
14493         texture.offsetscale = 1;
14494         texture.specularscalemod = 1;
14495         texture.specularpowermod = 1;
14496
14497         surface.texture = &texture;
14498         surface.num_triangles = numtriangles;
14499         surface.num_firsttriangle = firsttriangle;
14500         surface.num_vertices = numvertices;
14501         surface.num_firstvertex = firstvertex;
14502
14503         // now render it
14504         rsurface.texture = R_GetCurrentTexture(surface.texture);
14505         rsurface.lightmaptexture = NULL;
14506         rsurface.deluxemaptexture = NULL;
14507         rsurface.uselightmaptexture = false;
14508         R_DrawModelTextureSurfaceList(1, &surfacelist, writedepth, prepass);
14509 }
14510
14511 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)
14512 {
14513         static msurface_t surface;
14514         const msurface_t *surfacelist = &surface;
14515
14516         // fake enough texture and surface state to render this geometry
14517         surface.texture = texture;
14518         surface.num_triangles = numtriangles;
14519         surface.num_firsttriangle = firsttriangle;
14520         surface.num_vertices = numvertices;
14521         surface.num_firstvertex = firstvertex;
14522
14523         // now render it
14524         rsurface.texture = R_GetCurrentTexture(surface.texture);
14525         rsurface.lightmaptexture = NULL;
14526         rsurface.deluxemaptexture = NULL;
14527         rsurface.uselightmaptexture = false;
14528         R_DrawModelTextureSurfaceList(1, &surfacelist, writedepth, prepass);
14529 }