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) * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 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                         r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, org, ent->modellight_ambient, ent->modellight_diffuse, tempdiffusenormal);
7872                         if(ent->flags & RENDER_EQUALIZE)
7873                         {
7874                                 // first fix up ambient lighting...
7875                                 if(r_equalize_entities_minambient.value > 0)
7876                                 {
7877                                         fd = 0.299f * ent->modellight_diffuse[0] + 0.587f * ent->modellight_diffuse[1] + 0.114f * ent->modellight_diffuse[2];
7878                                         if(fd > 0)
7879                                         {
7880                                                 fa = (0.299f * ent->modellight_ambient[0] + 0.587f * ent->modellight_ambient[1] + 0.114f * ent->modellight_ambient[2]);
7881                                                 if(fa < r_equalize_entities_minambient.value * fd)
7882                                                 {
7883                                                         // solve:
7884                                                         //   fa'/fd' = minambient
7885                                                         //   fa'+0.25*fd' = fa+0.25*fd
7886                                                         //   ...
7887                                                         //   fa' = fd' * minambient
7888                                                         //   fd'*(0.25+minambient) = fa+0.25*fd
7889                                                         //   ...
7890                                                         //   fd' = (fa+0.25*fd) * 1 / (0.25+minambient)
7891                                                         //   fa' = (fa+0.25*fd) * minambient / (0.25+minambient)
7892                                                         //   ...
7893                                                         fdd = (fa + 0.25f * fd) / (0.25f + r_equalize_entities_minambient.value);
7894                                                         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
7895                                                         VectorMA(ent->modellight_ambient, (1-f)*0.25f, ent->modellight_diffuse, ent->modellight_ambient);
7896                                                         VectorScale(ent->modellight_diffuse, f, ent->modellight_diffuse);
7897                                                 }
7898                                         }
7899                                 }
7900
7901                                 if(r_equalize_entities_to.value > 0 && r_equalize_entities_by.value != 0)
7902                                 {
7903                                         VectorMA(ent->modellight_ambient, 0.25f, ent->modellight_diffuse, avg);
7904                                         f = 0.299f * avg[0] + 0.587f * avg[1] + 0.114f * avg[2];
7905                                         if(f > 0)
7906                                         {
7907                                                 f = pow(f / r_equalize_entities_to.value, -r_equalize_entities_by.value);
7908                                                 VectorScale(ent->modellight_ambient, f, ent->modellight_ambient);
7909                                                 VectorScale(ent->modellight_diffuse, f, ent->modellight_diffuse);
7910                                         }
7911                                 }
7912                         }
7913                 }
7914                 else // highly rare
7915                         VectorSet(ent->modellight_ambient, 1, 1, 1);
7916
7917                 // move the light direction into modelspace coordinates for lighting code
7918                 Matrix4x4_Transform3x3(&ent->inversematrix, tempdiffusenormal, ent->modellight_lightdir);
7919                 if(VectorLength2(ent->modellight_lightdir) == 0)
7920                         VectorSet(ent->modellight_lightdir, 0, 0, 1); // have to set SOME valid vector here
7921                 VectorNormalize(ent->modellight_lightdir);
7922         }
7923 }
7924
7925 #define MAX_LINEOFSIGHTTRACES 64
7926
7927 static qboolean R_CanSeeBox(int numsamples, vec_t enlarge, vec3_t eye, vec3_t entboxmins, vec3_t entboxmaxs)
7928 {
7929         int i;
7930         vec3_t boxmins, boxmaxs;
7931         vec3_t start;
7932         vec3_t end;
7933         dp_model_t *model = r_refdef.scene.worldmodel;
7934
7935         if (!model || !model->brush.TraceLineOfSight)
7936                 return true;
7937
7938         // expand the box a little
7939         boxmins[0] = (enlarge+1) * entboxmins[0] - enlarge * entboxmaxs[0];
7940         boxmaxs[0] = (enlarge+1) * entboxmaxs[0] - enlarge * entboxmins[0];
7941         boxmins[1] = (enlarge+1) * entboxmins[1] - enlarge * entboxmaxs[1];
7942         boxmaxs[1] = (enlarge+1) * entboxmaxs[1] - enlarge * entboxmins[1];
7943         boxmins[2] = (enlarge+1) * entboxmins[2] - enlarge * entboxmaxs[2];
7944         boxmaxs[2] = (enlarge+1) * entboxmaxs[2] - enlarge * entboxmins[2];
7945
7946         // return true if eye is inside enlarged box
7947         if (BoxesOverlap(boxmins, boxmaxs, eye, eye))
7948                 return true;
7949
7950         // try center
7951         VectorCopy(eye, start);
7952         VectorMAM(0.5f, boxmins, 0.5f, boxmaxs, end);
7953         if (model->brush.TraceLineOfSight(model, start, end))
7954                 return true;
7955
7956         // try various random positions
7957         for (i = 0;i < numsamples;i++)
7958         {
7959                 VectorSet(end, lhrandom(boxmins[0], boxmaxs[0]), lhrandom(boxmins[1], boxmaxs[1]), lhrandom(boxmins[2], boxmaxs[2]));
7960                 if (model->brush.TraceLineOfSight(model, start, end))
7961                         return true;
7962         }
7963
7964         return false;
7965 }
7966
7967
7968 static void R_View_UpdateEntityVisible (void)
7969 {
7970         int i;
7971         int renderimask;
7972         int samples;
7973         entity_render_t *ent;
7974
7975         renderimask = r_refdef.envmap                                    ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL)
7976                 : r_waterstate.renderingrefraction                       ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL)
7977                 : (chase_active.integer || r_waterstate.renderingscene)  ? RENDER_VIEWMODEL
7978                 :                                                          RENDER_EXTERIORMODEL;
7979         if (!r_drawviewmodel.integer)
7980                 renderimask |= RENDER_VIEWMODEL;
7981         if (!r_drawexteriormodel.integer)
7982                 renderimask |= RENDER_EXTERIORMODEL;
7983         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs)
7984         {
7985                 // worldmodel can check visibility
7986                 memset(r_refdef.viewcache.entityvisible, 0, r_refdef.scene.numentities);
7987                 for (i = 0;i < r_refdef.scene.numentities;i++)
7988                 {
7989                         ent = r_refdef.scene.entities[i];
7990                         if (!(ent->flags & renderimask))
7991                         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)))
7992                         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))
7993                                 r_refdef.viewcache.entityvisible[i] = true;
7994                 }
7995                 if(r_cullentities_trace.integer && r_refdef.scene.worldmodel->brush.TraceLineOfSight && !r_refdef.view.useclipplane)
7996                         // sorry, this check doesn't work for portal/reflection/refraction renders as the view origin is not useful for culling
7997                 {
7998                         for (i = 0;i < r_refdef.scene.numentities;i++)
7999                         {
8000                                 ent = r_refdef.scene.entities[i];
8001                                 if(r_refdef.viewcache.entityvisible[i] && !(ent->flags & (RENDER_VIEWMODEL | RENDER_NOCULL | RENDER_NODEPTHTEST)) && !(ent->model && (ent->model->name[0] == '*')))
8002                                 {
8003                                         samples = ent->entitynumber ? r_cullentities_trace_samples.integer : r_cullentities_trace_tempentitysamples.integer;
8004                                         if (samples < 0)
8005                                                 continue; // temp entities do pvs only
8006                                         if(R_CanSeeBox(samples, r_cullentities_trace_enlarge.value, r_refdef.view.origin, ent->mins, ent->maxs))
8007                                                 ent->last_trace_visibility = realtime;
8008                                         if(ent->last_trace_visibility < realtime - r_cullentities_trace_delay.value)
8009                                                 r_refdef.viewcache.entityvisible[i] = 0;
8010                                 }
8011                         }
8012                 }
8013         }
8014         else
8015         {
8016                 // no worldmodel or it can't check visibility
8017                 for (i = 0;i < r_refdef.scene.numentities;i++)
8018                 {
8019                         ent = r_refdef.scene.entities[i];
8020                         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));
8021                 }
8022         }
8023 }
8024
8025 /// only used if skyrendermasked, and normally returns false
8026 int R_DrawBrushModelsSky (void)
8027 {
8028         int i, sky;
8029         entity_render_t *ent;
8030
8031         sky = false;
8032         for (i = 0;i < r_refdef.scene.numentities;i++)
8033         {
8034                 if (!r_refdef.viewcache.entityvisible[i])
8035                         continue;
8036                 ent = r_refdef.scene.entities[i];
8037                 if (!ent->model || !ent->model->DrawSky)
8038                         continue;
8039                 ent->model->DrawSky(ent);
8040                 sky = true;
8041         }
8042         return sky;
8043 }
8044
8045 static void R_DrawNoModel(entity_render_t *ent);
8046 static void R_DrawModels(void)
8047 {
8048         int i;
8049         entity_render_t *ent;
8050
8051         for (i = 0;i < r_refdef.scene.numentities;i++)
8052         {
8053                 if (!r_refdef.viewcache.entityvisible[i])
8054                         continue;
8055                 ent = r_refdef.scene.entities[i];
8056                 r_refdef.stats.entities++;
8057                 if (ent->model && ent->model->Draw != NULL)
8058                         ent->model->Draw(ent);
8059                 else
8060                         R_DrawNoModel(ent);
8061         }
8062 }
8063
8064 static void R_DrawModelsDepth(void)
8065 {
8066         int i;
8067         entity_render_t *ent;
8068
8069         for (i = 0;i < r_refdef.scene.numentities;i++)
8070         {
8071                 if (!r_refdef.viewcache.entityvisible[i])
8072                         continue;
8073                 ent = r_refdef.scene.entities[i];
8074                 if (ent->model && ent->model->DrawDepth != NULL)
8075                         ent->model->DrawDepth(ent);
8076         }
8077 }
8078
8079 static void R_DrawModelsDebug(void)
8080 {
8081         int i;
8082         entity_render_t *ent;
8083
8084         for (i = 0;i < r_refdef.scene.numentities;i++)
8085         {
8086                 if (!r_refdef.viewcache.entityvisible[i])
8087                         continue;
8088                 ent = r_refdef.scene.entities[i];
8089                 if (ent->model && ent->model->DrawDebug != NULL)
8090                         ent->model->DrawDebug(ent);
8091         }
8092 }
8093
8094 static void R_DrawModelsAddWaterPlanes(void)
8095 {
8096         int i;
8097         entity_render_t *ent;
8098
8099         for (i = 0;i < r_refdef.scene.numentities;i++)
8100         {
8101                 if (!r_refdef.viewcache.entityvisible[i])
8102                         continue;
8103                 ent = r_refdef.scene.entities[i];
8104                 if (ent->model && ent->model->DrawAddWaterPlanes != NULL)
8105                         ent->model->DrawAddWaterPlanes(ent);
8106         }
8107 }
8108
8109 static void R_View_SetFrustum(const int *scissor)
8110 {
8111         int i;
8112         double fpx = +1, fnx = -1, fpy = +1, fny = -1;
8113         vec3_t forward, left, up, origin, v;
8114
8115         if(scissor)
8116         {
8117                 // flipped x coordinates (because x points left here)
8118                 fpx =  1.0 - 2.0 * (scissor[0]              - r_refdef.view.viewport.x) / (double) (r_refdef.view.viewport.width);
8119                 fnx =  1.0 - 2.0 * (scissor[0] + scissor[2] - r_refdef.view.viewport.x) / (double) (r_refdef.view.viewport.width);
8120
8121                 // D3D Y coordinate is top to bottom, OpenGL is bottom to top, fix the D3D one
8122                 switch(vid.renderpath)
8123                 {
8124                         case RENDERPATH_D3D9:
8125                         case RENDERPATH_D3D10:
8126                         case RENDERPATH_D3D11:
8127                                 // non-flipped y coordinates
8128                                 fny = -1.0 + 2.0 * (vid.height - scissor[1] - scissor[3] - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
8129                                 fpy = -1.0 + 2.0 * (vid.height - scissor[1]              - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
8130                                 break;
8131                         case RENDERPATH_GL11:
8132                         case RENDERPATH_GL13:
8133                         case RENDERPATH_GL20:
8134                         case RENDERPATH_CGGL:
8135                                 // non-flipped y coordinates
8136                                 fny = -1.0 + 2.0 * (scissor[1]              - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
8137                                 fpy = -1.0 + 2.0 * (scissor[1] + scissor[3] - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
8138                                 break;
8139                 }
8140         }
8141
8142         // we can't trust r_refdef.view.forward and friends in reflected scenes
8143         Matrix4x4_ToVectors(&r_refdef.view.matrix, forward, left, up, origin);
8144
8145 #if 0
8146         r_refdef.view.frustum[0].normal[0] = 0 - 1.0 / r_refdef.view.frustum_x;
8147         r_refdef.view.frustum[0].normal[1] = 0 - 0;
8148         r_refdef.view.frustum[0].normal[2] = -1 - 0;
8149         r_refdef.view.frustum[1].normal[0] = 0 + 1.0 / r_refdef.view.frustum_x;
8150         r_refdef.view.frustum[1].normal[1] = 0 + 0;
8151         r_refdef.view.frustum[1].normal[2] = -1 + 0;
8152         r_refdef.view.frustum[2].normal[0] = 0 - 0;
8153         r_refdef.view.frustum[2].normal[1] = 0 - 1.0 / r_refdef.view.frustum_y;
8154         r_refdef.view.frustum[2].normal[2] = -1 - 0;
8155         r_refdef.view.frustum[3].normal[0] = 0 + 0;
8156         r_refdef.view.frustum[3].normal[1] = 0 + 1.0 / r_refdef.view.frustum_y;
8157         r_refdef.view.frustum[3].normal[2] = -1 + 0;
8158 #endif
8159
8160 #if 0
8161         zNear = r_refdef.nearclip;
8162         nudge = 1.0 - 1.0 / (1<<23);
8163         r_refdef.view.frustum[4].normal[0] = 0 - 0;
8164         r_refdef.view.frustum[4].normal[1] = 0 - 0;
8165         r_refdef.view.frustum[4].normal[2] = -1 - -nudge;
8166         r_refdef.view.frustum[4].dist = 0 - -2 * zNear * nudge;
8167         r_refdef.view.frustum[5].normal[0] = 0 + 0;
8168         r_refdef.view.frustum[5].normal[1] = 0 + 0;
8169         r_refdef.view.frustum[5].normal[2] = -1 + -nudge;
8170         r_refdef.view.frustum[5].dist = 0 + -2 * zNear * nudge;
8171 #endif
8172
8173
8174
8175 #if 0
8176         r_refdef.view.frustum[0].normal[0] = m[3] - m[0];
8177         r_refdef.view.frustum[0].normal[1] = m[7] - m[4];
8178         r_refdef.view.frustum[0].normal[2] = m[11] - m[8];
8179         r_refdef.view.frustum[0].dist = m[15] - m[12];
8180
8181         r_refdef.view.frustum[1].normal[0] = m[3] + m[0];
8182         r_refdef.view.frustum[1].normal[1] = m[7] + m[4];
8183         r_refdef.view.frustum[1].normal[2] = m[11] + m[8];
8184         r_refdef.view.frustum[1].dist = m[15] + m[12];
8185
8186         r_refdef.view.frustum[2].normal[0] = m[3] - m[1];
8187         r_refdef.view.frustum[2].normal[1] = m[7] - m[5];
8188         r_refdef.view.frustum[2].normal[2] = m[11] - m[9];
8189         r_refdef.view.frustum[2].dist = m[15] - m[13];
8190
8191         r_refdef.view.frustum[3].normal[0] = m[3] + m[1];
8192         r_refdef.view.frustum[3].normal[1] = m[7] + m[5];
8193         r_refdef.view.frustum[3].normal[2] = m[11] + m[9];
8194         r_refdef.view.frustum[3].dist = m[15] + m[13];
8195
8196         r_refdef.view.frustum[4].normal[0] = m[3] - m[2];
8197         r_refdef.view.frustum[4].normal[1] = m[7] - m[6];
8198         r_refdef.view.frustum[4].normal[2] = m[11] - m[10];
8199         r_refdef.view.frustum[4].dist = m[15] - m[14];
8200
8201         r_refdef.view.frustum[5].normal[0] = m[3] + m[2];
8202         r_refdef.view.frustum[5].normal[1] = m[7] + m[6];
8203         r_refdef.view.frustum[5].normal[2] = m[11] + m[10];
8204         r_refdef.view.frustum[5].dist = m[15] + m[14];
8205 #endif
8206
8207         if (r_refdef.view.useperspective)
8208         {
8209                 // calculate frustum corners, which are used to calculate deformed frustum planes for shadow caster culling
8210                 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]);
8211                 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]);
8212                 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]);
8213                 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]);
8214
8215                 // then the normals from the corners relative to origin
8216                 CrossProduct(r_refdef.view.frustumcorner[2], r_refdef.view.frustumcorner[0], r_refdef.view.frustum[0].normal);
8217                 CrossProduct(r_refdef.view.frustumcorner[1], r_refdef.view.frustumcorner[3], r_refdef.view.frustum[1].normal);
8218                 CrossProduct(r_refdef.view.frustumcorner[0], r_refdef.view.frustumcorner[1], r_refdef.view.frustum[2].normal);
8219                 CrossProduct(r_refdef.view.frustumcorner[3], r_refdef.view.frustumcorner[2], r_refdef.view.frustum[3].normal);
8220
8221                 // in a NORMAL view, forward cross left == up
8222                 // in a REFLECTED view, forward cross left == down
8223                 // so our cross products above need to be adjusted for a left handed coordinate system
8224                 CrossProduct(forward, left, v);
8225                 if(DotProduct(v, up) < 0)
8226                 {
8227                         VectorNegate(r_refdef.view.frustum[0].normal, r_refdef.view.frustum[0].normal);
8228                         VectorNegate(r_refdef.view.frustum[1].normal, r_refdef.view.frustum[1].normal);
8229                         VectorNegate(r_refdef.view.frustum[2].normal, r_refdef.view.frustum[2].normal);
8230                         VectorNegate(r_refdef.view.frustum[3].normal, r_refdef.view.frustum[3].normal);
8231                 }
8232
8233                 // Leaving those out was a mistake, those were in the old code, and they
8234                 // fix a reproducable bug in this one: frustum culling got fucked up when viewmatrix was an identity matrix
8235                 // I couldn't reproduce it after adding those normalizations. --blub
8236                 VectorNormalize(r_refdef.view.frustum[0].normal);
8237                 VectorNormalize(r_refdef.view.frustum[1].normal);
8238                 VectorNormalize(r_refdef.view.frustum[2].normal);
8239                 VectorNormalize(r_refdef.view.frustum[3].normal);
8240
8241                 // make the corners absolute
8242                 VectorAdd(r_refdef.view.frustumcorner[0], r_refdef.view.origin, r_refdef.view.frustumcorner[0]);
8243                 VectorAdd(r_refdef.view.frustumcorner[1], r_refdef.view.origin, r_refdef.view.frustumcorner[1]);
8244                 VectorAdd(r_refdef.view.frustumcorner[2], r_refdef.view.origin, r_refdef.view.frustumcorner[2]);
8245                 VectorAdd(r_refdef.view.frustumcorner[3], r_refdef.view.origin, r_refdef.view.frustumcorner[3]);
8246
8247                 // one more normal
8248                 VectorCopy(forward, r_refdef.view.frustum[4].normal);
8249
8250                 r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[0].normal);
8251                 r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[1].normal);
8252                 r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[2].normal);
8253                 r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[3].normal);
8254                 r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[4].normal) + r_refdef.nearclip;
8255         }
8256         else
8257         {
8258                 VectorScale(left, -r_refdef.view.ortho_x, r_refdef.view.frustum[0].normal);
8259                 VectorScale(left,  r_refdef.view.ortho_x, r_refdef.view.frustum[1].normal);
8260                 VectorScale(up, -r_refdef.view.ortho_y, r_refdef.view.frustum[2].normal);
8261                 VectorScale(up,  r_refdef.view.ortho_y, r_refdef.view.frustum[3].normal);
8262                 VectorCopy(forward, r_refdef.view.frustum[4].normal);
8263                 r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[0].normal) + r_refdef.view.ortho_x;
8264                 r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[1].normal) + r_refdef.view.ortho_x;
8265                 r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[2].normal) + r_refdef.view.ortho_y;
8266                 r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[3].normal) + r_refdef.view.ortho_y;
8267                 r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[4].normal) + r_refdef.nearclip;
8268         }
8269         r_refdef.view.numfrustumplanes = 5;
8270
8271         if (r_refdef.view.useclipplane)
8272         {
8273                 r_refdef.view.numfrustumplanes = 6;
8274                 r_refdef.view.frustum[5] = r_refdef.view.clipplane;
8275         }
8276
8277         for (i = 0;i < r_refdef.view.numfrustumplanes;i++)
8278                 PlaneClassify(r_refdef.view.frustum + i);
8279
8280         // LordHavoc: note to all quake engine coders, Quake had a special case
8281         // for 90 degrees which assumed a square view (wrong), so I removed it,
8282         // Quake2 has it disabled as well.
8283
8284         // rotate R_VIEWFORWARD right by FOV_X/2 degrees
8285         //RotatePointAroundVector( r_refdef.view.frustum[0].normal, up, forward, -(90 - r_refdef.fov_x / 2));
8286         //r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, frustum[0].normal);
8287         //PlaneClassify(&frustum[0]);
8288
8289         // rotate R_VIEWFORWARD left by FOV_X/2 degrees
8290         //RotatePointAroundVector( r_refdef.view.frustum[1].normal, up, forward, (90 - r_refdef.fov_x / 2));
8291         //r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, frustum[1].normal);
8292         //PlaneClassify(&frustum[1]);
8293
8294         // rotate R_VIEWFORWARD up by FOV_X/2 degrees
8295         //RotatePointAroundVector( r_refdef.view.frustum[2].normal, left, forward, -(90 - r_refdef.fov_y / 2));
8296         //r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, frustum[2].normal);
8297         //PlaneClassify(&frustum[2]);
8298
8299         // rotate R_VIEWFORWARD down by FOV_X/2 degrees
8300         //RotatePointAroundVector( r_refdef.view.frustum[3].normal, left, forward, (90 - r_refdef.fov_y / 2));
8301         //r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, frustum[3].normal);
8302         //PlaneClassify(&frustum[3]);
8303
8304         // nearclip plane
8305         //VectorCopy(forward, r_refdef.view.frustum[4].normal);
8306         //r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, frustum[4].normal) + r_nearclip.value;
8307         //PlaneClassify(&frustum[4]);
8308 }
8309
8310 void R_View_UpdateWithScissor(const int *myscissor)
8311 {
8312         R_Main_ResizeViewCache();
8313         R_View_SetFrustum(myscissor);
8314         R_View_WorldVisibility(r_refdef.view.useclipplane);
8315         R_View_UpdateEntityVisible();
8316         R_View_UpdateEntityLighting();
8317 }
8318
8319 void R_View_Update(void)
8320 {
8321         R_Main_ResizeViewCache();
8322         R_View_SetFrustum(NULL);
8323         R_View_WorldVisibility(r_refdef.view.useclipplane);
8324         R_View_UpdateEntityVisible();
8325         R_View_UpdateEntityLighting();
8326 }
8327
8328 void R_SetupView(qboolean allowwaterclippingplane)
8329 {
8330         const float *customclipplane = NULL;
8331         float plane[4];
8332         if (r_refdef.view.useclipplane && allowwaterclippingplane)
8333         {
8334                 // LordHavoc: couldn't figure out how to make this approach the
8335                 vec_t dist = r_refdef.view.clipplane.dist - r_water_clippingplanebias.value;
8336                 vec_t viewdist = DotProduct(r_refdef.view.origin, r_refdef.view.clipplane.normal);
8337                 if (viewdist < r_refdef.view.clipplane.dist + r_water_clippingplanebias.value)
8338                         dist = r_refdef.view.clipplane.dist;
8339                 plane[0] = r_refdef.view.clipplane.normal[0];
8340                 plane[1] = r_refdef.view.clipplane.normal[1];
8341                 plane[2] = r_refdef.view.clipplane.normal[2];
8342                 plane[3] = dist;
8343                 customclipplane = plane;
8344         }
8345
8346         if (!r_refdef.view.useperspective)
8347                 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);
8348         else if (vid.stencil && r_useinfinitefarclip.integer)
8349                 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);
8350         else
8351                 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);
8352         R_SetViewport(&r_refdef.view.viewport);
8353 }
8354
8355 void R_EntityMatrix(const matrix4x4_t *matrix)
8356 {
8357         if (gl_modelmatrixchanged || memcmp(matrix, &gl_modelmatrix, sizeof(matrix4x4_t)))
8358         {
8359                 gl_modelmatrixchanged = false;
8360                 gl_modelmatrix = *matrix;
8361                 Matrix4x4_Concat(&gl_modelviewmatrix, &gl_viewmatrix, &gl_modelmatrix);
8362                 Matrix4x4_Concat(&gl_modelviewprojectionmatrix, &gl_projectionmatrix, &gl_modelviewmatrix);
8363                 Matrix4x4_ToArrayFloatGL(&gl_modelviewmatrix, gl_modelview16f);
8364                 Matrix4x4_ToArrayFloatGL(&gl_modelviewprojectionmatrix, gl_modelviewprojection16f);
8365                 CHECKGLERROR
8366                 switch(vid.renderpath)
8367                 {
8368                 case RENDERPATH_D3D9:
8369 #ifdef SUPPORTD3D
8370                         hlslVSSetParameter16f(D3DVSREGISTER_ModelViewProjectionMatrix, gl_modelviewprojection16f);
8371                         hlslVSSetParameter16f(D3DVSREGISTER_ModelViewMatrix, gl_modelview16f);
8372 #endif
8373                         break;
8374                 case RENDERPATH_D3D10:
8375                         Con_DPrintf("FIXME D3D10 shader %s:%i\n", __FILE__, __LINE__);
8376                         break;
8377                 case RENDERPATH_D3D11:
8378                         Con_DPrintf("FIXME D3D11 shader %s:%i\n", __FILE__, __LINE__);
8379                         break;
8380                 case RENDERPATH_GL20:
8381                         if (r_glsl_permutation && r_glsl_permutation->loc_ModelViewProjectionMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewProjectionMatrix, 1, false, gl_modelviewprojection16f);
8382                         if (r_glsl_permutation && r_glsl_permutation->loc_ModelViewMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewMatrix, 1, false, gl_modelview16f);
8383                         qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
8384                         break;
8385                 case RENDERPATH_CGGL:
8386 #ifdef SUPPORTCG
8387                         CHECKCGERROR
8388                         if (r_cg_permutation && r_cg_permutation->vp_ModelViewProjectionMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewProjectionMatrix, gl_modelviewprojection16f);CHECKCGERROR
8389                         if (r_cg_permutation && r_cg_permutation->vp_ModelViewMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewMatrix, gl_modelview16f);CHECKCGERROR
8390                         qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
8391 #endif
8392                         break;
8393                 case RENDERPATH_GL13:
8394                 case RENDERPATH_GL11:
8395                         qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
8396                         break;
8397                 }
8398         }
8399 }
8400
8401 void R_ResetViewRendering2D(void)
8402 {
8403         r_viewport_t viewport;
8404         DrawQ_Finish();
8405
8406         // GL is weird because it's bottom to top, r_refdef.view.y is top to bottom
8407         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);
8408         R_SetViewport(&viewport);
8409         GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
8410         GL_Color(1, 1, 1, 1);
8411         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
8412         GL_BlendFunc(GL_ONE, GL_ZERO);
8413         GL_AlphaTest(false);
8414         GL_ScissorTest(false);
8415         GL_DepthMask(false);
8416         GL_DepthRange(0, 1);
8417         GL_DepthTest(false);
8418         GL_DepthFunc(GL_LEQUAL);
8419         R_EntityMatrix(&identitymatrix);
8420         R_Mesh_ResetTextureState();
8421         GL_PolygonOffset(0, 0);
8422         R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255);
8423         switch(vid.renderpath)
8424         {
8425         case RENDERPATH_GL11:
8426         case RENDERPATH_GL13:
8427         case RENDERPATH_GL20:
8428         case RENDERPATH_CGGL:
8429                 qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
8430                 break;
8431         case RENDERPATH_D3D9:
8432         case RENDERPATH_D3D10:
8433         case RENDERPATH_D3D11:
8434                 break;
8435         }
8436         GL_CullFace(GL_NONE);
8437 }
8438
8439 void R_ResetViewRendering3D(void)
8440 {
8441         DrawQ_Finish();
8442
8443         R_SetupView(true);
8444         GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
8445         GL_Color(1, 1, 1, 1);
8446         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
8447         GL_BlendFunc(GL_ONE, GL_ZERO);
8448         GL_AlphaTest(false);
8449         GL_ScissorTest(true);
8450         GL_DepthMask(true);
8451         GL_DepthRange(0, 1);
8452         GL_DepthTest(true);
8453         GL_DepthFunc(GL_LEQUAL);
8454         R_EntityMatrix(&identitymatrix);
8455         R_Mesh_ResetTextureState();
8456         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
8457         R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255);
8458         switch(vid.renderpath)
8459         {
8460         case RENDERPATH_GL11:
8461         case RENDERPATH_GL13:
8462         case RENDERPATH_GL20:
8463         case RENDERPATH_CGGL:
8464                 qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
8465                 break;
8466         case RENDERPATH_D3D9:
8467         case RENDERPATH_D3D10:
8468         case RENDERPATH_D3D11:
8469                 break;
8470         }
8471         GL_CullFace(r_refdef.view.cullface_back);
8472 }
8473
8474 /*
8475 ================
8476 R_RenderView_UpdateViewVectors
8477 ================
8478 */
8479 static void R_RenderView_UpdateViewVectors(void)
8480 {
8481         // break apart the view matrix into vectors for various purposes
8482         // it is important that this occurs outside the RenderScene function because that can be called from reflection renders, where the vectors come out wrong
8483         // however the r_refdef.view.origin IS updated in RenderScene intentionally - otherwise the sky renders at the wrong origin, etc
8484         Matrix4x4_ToVectors(&r_refdef.view.matrix, r_refdef.view.forward, r_refdef.view.left, r_refdef.view.up, r_refdef.view.origin);
8485         VectorNegate(r_refdef.view.left, r_refdef.view.right);
8486         // make an inverted copy of the view matrix for tracking sprites
8487         Matrix4x4_Invert_Simple(&r_refdef.view.inverse_matrix, &r_refdef.view.matrix);
8488 }
8489
8490 void R_RenderScene(void);
8491 void R_RenderWaterPlanes(void);
8492
8493 static void R_Water_StartFrame(void)
8494 {
8495         int i;
8496         int waterwidth, waterheight, texturewidth, textureheight, camerawidth, cameraheight;
8497         r_waterstate_waterplane_t *p;
8498
8499         if (vid.width > (int)vid.maxtexturesize_2d || vid.height > (int)vid.maxtexturesize_2d)
8500                 return;
8501
8502         switch(vid.renderpath)
8503         {
8504         case RENDERPATH_GL20:
8505         case RENDERPATH_CGGL:
8506         case RENDERPATH_D3D9:
8507         case RENDERPATH_D3D10:
8508         case RENDERPATH_D3D11:
8509                 break;
8510         case RENDERPATH_GL13:
8511         case RENDERPATH_GL11:
8512                 return;
8513         }
8514
8515         // set waterwidth and waterheight to the water resolution that will be
8516         // used (often less than the screen resolution for faster rendering)
8517         waterwidth = (int)bound(1, vid.width * r_water_resolutionmultiplier.value, vid.width);
8518         waterheight = (int)bound(1, vid.height * r_water_resolutionmultiplier.value, vid.height);
8519
8520         // calculate desired texture sizes
8521         // can't use water if the card does not support the texture size
8522         if (!r_water.integer || r_showsurfaces.integer)
8523                 texturewidth = textureheight = waterwidth = waterheight = camerawidth = cameraheight = 0;
8524         else if (vid.support.arb_texture_non_power_of_two)
8525         {
8526                 texturewidth = waterwidth;
8527                 textureheight = waterheight;
8528                 camerawidth = waterwidth;
8529                 cameraheight = waterheight;
8530         }
8531         else
8532         {
8533                 for (texturewidth   = 1;texturewidth   < waterwidth ;texturewidth   *= 2);
8534                 for (textureheight  = 1;textureheight  < waterheight;textureheight  *= 2);
8535                 for (camerawidth    = 1;camerawidth   <= waterwidth; camerawidth    *= 2); camerawidth  /= 2;
8536                 for (cameraheight   = 1;cameraheight  <= waterheight;cameraheight   *= 2); cameraheight /= 2;
8537         }
8538
8539         // allocate textures as needed
8540         if (r_waterstate.texturewidth != texturewidth || r_waterstate.textureheight != textureheight || r_waterstate.camerawidth != camerawidth || r_waterstate.cameraheight != cameraheight)
8541         {
8542                 r_waterstate.maxwaterplanes = MAX_WATERPLANES;
8543                 for (i = 0, p = r_waterstate.waterplanes;i < r_waterstate.maxwaterplanes;i++, p++)
8544                 {
8545                         if (p->texture_refraction)
8546                                 R_FreeTexture(p->texture_refraction);
8547                         p->texture_refraction = NULL;
8548                         if (p->texture_reflection)
8549                                 R_FreeTexture(p->texture_reflection);
8550                         p->texture_reflection = NULL;
8551                         if (p->texture_camera)
8552                                 R_FreeTexture(p->texture_camera);
8553                         p->texture_camera = NULL;
8554                 }
8555                 memset(&r_waterstate, 0, sizeof(r_waterstate));
8556                 r_waterstate.texturewidth = texturewidth;
8557                 r_waterstate.textureheight = textureheight;
8558                 r_waterstate.camerawidth = camerawidth;
8559                 r_waterstate.cameraheight = cameraheight;
8560         }
8561
8562         if (r_waterstate.texturewidth)
8563         {
8564                 r_waterstate.enabled = true;
8565
8566                 // when doing a reduced render (HDR) we want to use a smaller area
8567                 r_waterstate.waterwidth = (int)bound(1, r_refdef.view.width * r_water_resolutionmultiplier.value, r_refdef.view.width);
8568                 r_waterstate.waterheight = (int)bound(1, r_refdef.view.height * r_water_resolutionmultiplier.value, r_refdef.view.height);
8569
8570                 // set up variables that will be used in shader setup
8571                 r_waterstate.screenscale[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
8572                 r_waterstate.screenscale[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
8573                 r_waterstate.screencenter[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
8574                 r_waterstate.screencenter[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
8575         }
8576
8577         r_waterstate.maxwaterplanes = MAX_WATERPLANES;
8578         r_waterstate.numwaterplanes = 0;
8579 }
8580
8581 void R_Water_AddWaterPlane(msurface_t *surface, int entno)
8582 {
8583         int triangleindex, planeindex;
8584         const int *e;
8585         vec3_t vert[3];
8586         vec3_t normal;
8587         vec3_t center;
8588         mplane_t plane;
8589         r_waterstate_waterplane_t *p;
8590         texture_t *t = R_GetCurrentTexture(surface->texture);
8591
8592         // just use the first triangle with a valid normal for any decisions
8593         VectorClear(normal);
8594         for (triangleindex = 0, e = rsurface.modelelement3i + surface->num_firsttriangle * 3;triangleindex < surface->num_triangles;triangleindex++, e += 3)
8595         {
8596                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[0]*3, vert[0]);
8597                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[1]*3, vert[1]);
8598                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[2]*3, vert[2]);
8599                 TriangleNormal(vert[0], vert[1], vert[2], normal);
8600                 if (VectorLength2(normal) >= 0.001)
8601                         break;
8602         }
8603
8604         VectorCopy(normal, plane.normal);
8605         VectorNormalize(plane.normal);
8606         plane.dist = DotProduct(vert[0], plane.normal);
8607         PlaneClassify(&plane);
8608         if (PlaneDiff(r_refdef.view.origin, &plane) < 0)
8609         {
8610                 // skip backfaces (except if nocullface is set)
8611                 if (!(t->currentmaterialflags & MATERIALFLAG_NOCULLFACE))
8612                         return;
8613                 VectorNegate(plane.normal, plane.normal);
8614                 plane.dist *= -1;
8615                 PlaneClassify(&plane);
8616         }
8617
8618
8619         // find a matching plane if there is one
8620         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
8621                 if(p->camera_entity == t->camera_entity)
8622                         if (fabs(PlaneDiff(vert[0], &p->plane)) < 1 && fabs(PlaneDiff(vert[1], &p->plane)) < 1 && fabs(PlaneDiff(vert[2], &p->plane)) < 1)
8623                                 break;
8624         if (planeindex >= r_waterstate.maxwaterplanes)
8625                 return; // nothing we can do, out of planes
8626
8627         // if this triangle does not fit any known plane rendered this frame, add one
8628         if (planeindex >= r_waterstate.numwaterplanes)
8629         {
8630                 // store the new plane
8631                 r_waterstate.numwaterplanes++;
8632                 p->plane = plane;
8633                 // clear materialflags and pvs
8634                 p->materialflags = 0;
8635                 p->pvsvalid = false;
8636                 p->camera_entity = t->camera_entity;
8637                 VectorCopy(surface->mins, p->mins);
8638                 VectorCopy(surface->maxs, p->maxs);
8639         }
8640         else
8641         {
8642                 // merge mins/maxs
8643                 p->mins[0] = min(p->mins[0], surface->mins[0]);
8644                 p->mins[1] = min(p->mins[1], surface->mins[1]);
8645                 p->mins[2] = min(p->mins[2], surface->mins[2]);
8646                 p->maxs[0] = max(p->maxs[0], surface->maxs[0]);
8647                 p->maxs[1] = max(p->maxs[1], surface->maxs[1]);
8648                 p->maxs[2] = max(p->maxs[2], surface->maxs[2]);
8649         }
8650         // merge this surface's materialflags into the waterplane
8651         p->materialflags |= t->currentmaterialflags;
8652         if(!(p->materialflags & MATERIALFLAG_CAMERA))
8653         {
8654                 // merge this surface's PVS into the waterplane
8655                 VectorMAM(0.5f, surface->mins, 0.5f, surface->maxs, center);
8656                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS
8657                  && r_refdef.scene.worldmodel->brush.PointInLeaf && r_refdef.scene.worldmodel->brush.PointInLeaf(r_refdef.scene.worldmodel, center)->clusterindex >= 0)
8658                 {
8659                         r_refdef.scene.worldmodel->brush.FatPVS(r_refdef.scene.worldmodel, center, 2, p->pvsbits, sizeof(p->pvsbits), p->pvsvalid);
8660                         p->pvsvalid = true;
8661                 }
8662         }
8663 }
8664
8665 static void R_Water_ProcessPlanes(void)
8666 {
8667         int myscissor[4];
8668         r_refdef_view_t originalview;
8669         r_refdef_view_t myview;
8670         int planeindex;
8671         r_waterstate_waterplane_t *p;
8672         vec3_t visorigin;
8673
8674         originalview = r_refdef.view;
8675
8676         // make sure enough textures are allocated
8677         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
8678         {
8679                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
8680                 {
8681                         if (!p->texture_refraction)
8682                                 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);
8683                         if (!p->texture_refraction)
8684                                 goto error;
8685                 }
8686                 else if (p->materialflags & MATERIALFLAG_CAMERA)
8687                 {
8688                         if (!p->texture_camera)
8689                                 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);
8690                         if (!p->texture_camera)
8691                                 goto error;
8692                 }
8693
8694                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
8695                 {
8696                         if (!p->texture_reflection)
8697                                 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);
8698                         if (!p->texture_reflection)
8699                                 goto error;
8700                 }
8701         }
8702
8703         // render views
8704         r_refdef.view = originalview;
8705         r_refdef.view.showdebug = false;
8706         r_refdef.view.width = r_waterstate.waterwidth;
8707         r_refdef.view.height = r_waterstate.waterheight;
8708         r_refdef.view.useclipplane = true;
8709         myview = r_refdef.view;
8710         r_waterstate.renderingscene = true;
8711         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
8712         {
8713                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
8714                 {
8715                         r_refdef.view = myview;
8716                         if(r_water_scissormode.integer)
8717                         {
8718                                 R_SetupView(true);
8719                                 if(R_ScissorForBBox(p->mins, p->maxs, myscissor))
8720                                         continue; // FIXME the plane then still may get rendered but with broken texture, but it sure won't be visible
8721                         }
8722
8723                         // render reflected scene and copy into texture
8724                         Matrix4x4_Reflect(&r_refdef.view.matrix, p->plane.normal[0], p->plane.normal[1], p->plane.normal[2], p->plane.dist, -2);
8725                         // update the r_refdef.view.origin because otherwise the sky renders at the wrong location (amongst other problems)
8726                         Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, r_refdef.view.origin);
8727                         r_refdef.view.clipplane = p->plane;
8728
8729                         // reverse the cullface settings for this render
8730                         r_refdef.view.cullface_front = GL_FRONT;
8731                         r_refdef.view.cullface_back = GL_BACK;
8732                         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.num_pvsclusterbytes)
8733                         {
8734                                 r_refdef.view.usecustompvs = true;
8735                                 if (p->pvsvalid)
8736                                         memcpy(r_refdef.viewcache.world_pvsbits, p->pvsbits, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
8737                                 else
8738                                         memset(r_refdef.viewcache.world_pvsbits, 0xFF, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
8739                         }
8740
8741                         R_ResetViewRendering3D();
8742                         R_ClearScreen(r_refdef.fogenabled);
8743                         if(r_water_scissormode.integer & 2)
8744                                 R_View_UpdateWithScissor(myscissor);
8745                         else
8746                                 R_View_Update();
8747                         if(r_water_scissormode.integer & 1)
8748                                 GL_Scissor(myscissor[0], myscissor[1], myscissor[2], myscissor[3]);
8749                         R_RenderScene();
8750
8751                         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);
8752                 }
8753
8754                 // render the normal view scene and copy into texture
8755                 // (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)
8756                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
8757                 {
8758                         r_refdef.view = myview;
8759                         if(r_water_scissormode.integer)
8760                         {
8761                                 R_SetupView(true);
8762                                 if(R_ScissorForBBox(p->mins, p->maxs, myscissor))
8763                                         continue; // FIXME the plane then still may get rendered but with broken texture, but it sure won't be visible
8764                         }
8765
8766                         r_waterstate.renderingrefraction = true;
8767
8768                         r_refdef.view.clipplane = p->plane;
8769                         VectorNegate(r_refdef.view.clipplane.normal, r_refdef.view.clipplane.normal);
8770                         r_refdef.view.clipplane.dist = -r_refdef.view.clipplane.dist;
8771
8772                         if((p->materialflags & MATERIALFLAG_CAMERA) && p->camera_entity)
8773                         {
8774                                 // we need to perform a matrix transform to render the view... so let's get the transformation matrix
8775                                 r_waterstate.renderingrefraction = false; // we don't want to hide the player model from these ones
8776                                 CL_VM_TransformView(p->camera_entity - MAX_EDICTS, &r_refdef.view.matrix, &r_refdef.view.clipplane, visorigin);
8777                                 R_RenderView_UpdateViewVectors();
8778                                 if(r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS)
8779                                 {
8780                                         r_refdef.view.usecustompvs = true;
8781                                         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);
8782                                 }
8783                         }
8784
8785                         PlaneClassify(&r_refdef.view.clipplane);
8786
8787                         R_ResetViewRendering3D();
8788                         R_ClearScreen(r_refdef.fogenabled);
8789                         if(r_water_scissormode.integer & 2)
8790                                 R_View_UpdateWithScissor(myscissor);
8791                         else
8792                                 R_View_Update();
8793                         if(r_water_scissormode.integer & 1)
8794                                 GL_Scissor(myscissor[0], myscissor[1], myscissor[2], myscissor[3]);
8795                         R_RenderScene();
8796
8797                         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);
8798                         r_waterstate.renderingrefraction = false;
8799                 }
8800                 else if (p->materialflags & MATERIALFLAG_CAMERA)
8801                 {
8802                         r_refdef.view = myview;
8803
8804                         r_refdef.view.clipplane = p->plane;
8805                         VectorNegate(r_refdef.view.clipplane.normal, r_refdef.view.clipplane.normal);
8806                         r_refdef.view.clipplane.dist = -r_refdef.view.clipplane.dist;
8807
8808                         r_refdef.view.width = r_waterstate.camerawidth;
8809                         r_refdef.view.height = r_waterstate.cameraheight;
8810                         r_refdef.view.frustum_x = 1; // tan(45 * M_PI / 180.0);
8811                         r_refdef.view.frustum_y = 1; // tan(45 * M_PI / 180.0);
8812
8813                         if(p->camera_entity)
8814                         {
8815                                 // we need to perform a matrix transform to render the view... so let's get the transformation matrix
8816                                 CL_VM_TransformView(p->camera_entity - MAX_EDICTS, &r_refdef.view.matrix, &r_refdef.view.clipplane, visorigin);
8817                         }
8818
8819                         // note: all of the view is used for displaying... so
8820                         // there is no use in scissoring
8821
8822                         // reverse the cullface settings for this render
8823                         r_refdef.view.cullface_front = GL_FRONT;
8824                         r_refdef.view.cullface_back = GL_BACK;
8825                         // also reverse the view matrix
8826                         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
8827                         R_RenderView_UpdateViewVectors();
8828                         if(p->camera_entity && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS)
8829                         {
8830                                 r_refdef.view.usecustompvs = true;
8831                                 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);
8832                         }
8833
8834                         // camera needs no clipplane
8835                         r_refdef.view.useclipplane = false;
8836
8837                         PlaneClassify(&r_refdef.view.clipplane);
8838
8839                         R_ResetViewRendering3D();
8840                         R_ClearScreen(r_refdef.fogenabled);
8841                         R_View_Update();
8842                         R_RenderScene();
8843
8844                         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);
8845                         r_waterstate.renderingrefraction = false;
8846                 }
8847
8848         }
8849         r_waterstate.renderingscene = false;
8850         r_refdef.view = originalview;
8851         R_ResetViewRendering3D();
8852         R_ClearScreen(r_refdef.fogenabled);
8853         R_View_Update();
8854         return;
8855 error:
8856         r_refdef.view = originalview;
8857         r_waterstate.renderingscene = false;
8858         Cvar_SetValueQuick(&r_water, 0);
8859         Con_Printf("R_Water_ProcessPlanes: Error: texture creation failed!  Turned off r_water.\n");
8860         return;
8861 }
8862
8863 void R_Bloom_StartFrame(void)
8864 {
8865         int bloomtexturewidth, bloomtextureheight, screentexturewidth, screentextureheight;
8866
8867         switch(vid.renderpath)
8868         {
8869         case RENDERPATH_GL20:
8870         case RENDERPATH_CGGL:
8871         case RENDERPATH_D3D9:
8872         case RENDERPATH_D3D10:
8873         case RENDERPATH_D3D11:
8874                 break;
8875         case RENDERPATH_GL13:
8876         case RENDERPATH_GL11:
8877                 return;
8878         }
8879
8880         // set bloomwidth and bloomheight to the bloom resolution that will be
8881         // used (often less than the screen resolution for faster rendering)
8882         r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, vid.height);
8883         r_bloomstate.bloomheight = r_bloomstate.bloomwidth * vid.height / vid.width;
8884         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, vid.height);
8885         r_bloomstate.bloomwidth = bound(1, r_bloomstate.bloomwidth, (int)vid.maxtexturesize_2d);
8886         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, (int)vid.maxtexturesize_2d);
8887
8888         // calculate desired texture sizes
8889         if (vid.support.arb_texture_non_power_of_two)
8890         {
8891                 screentexturewidth = r_refdef.view.width;
8892                 screentextureheight = r_refdef.view.height;
8893                 bloomtexturewidth = r_bloomstate.bloomwidth;
8894                 bloomtextureheight = r_bloomstate.bloomheight;
8895         }
8896         else
8897         {
8898                 for (screentexturewidth  = 1;screentexturewidth  < vid.width               ;screentexturewidth  *= 2);
8899                 for (screentextureheight = 1;screentextureheight < vid.height              ;screentextureheight *= 2);
8900                 for (bloomtexturewidth   = 1;bloomtexturewidth   < r_bloomstate.bloomwidth ;bloomtexturewidth   *= 2);
8901                 for (bloomtextureheight  = 1;bloomtextureheight  < r_bloomstate.bloomheight;bloomtextureheight  *= 2);
8902         }
8903
8904         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))
8905         {
8906                 Cvar_SetValueQuick(&r_hdr, 0);
8907                 Cvar_SetValueQuick(&r_bloom, 0);
8908                 Cvar_SetValueQuick(&r_motionblur, 0);
8909                 Cvar_SetValueQuick(&r_damageblur, 0);
8910         }
8911
8912         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)))
8913                 screentexturewidth = screentextureheight = 0;
8914         if (!r_hdr.integer && !r_bloom.integer)
8915                 bloomtexturewidth = bloomtextureheight = 0;
8916
8917         // allocate textures as needed
8918         if (r_bloomstate.screentexturewidth != screentexturewidth || r_bloomstate.screentextureheight != screentextureheight)
8919         {
8920                 if (r_bloomstate.texture_screen)
8921                         R_FreeTexture(r_bloomstate.texture_screen);
8922                 r_bloomstate.texture_screen = NULL;
8923                 r_bloomstate.screentexturewidth = screentexturewidth;
8924                 r_bloomstate.screentextureheight = screentextureheight;
8925                 if (r_bloomstate.screentexturewidth && r_bloomstate.screentextureheight)
8926                         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);
8927         }
8928         if (r_bloomstate.bloomtexturewidth != bloomtexturewidth || r_bloomstate.bloomtextureheight != bloomtextureheight)
8929         {
8930                 if (r_bloomstate.texture_bloom)
8931                         R_FreeTexture(r_bloomstate.texture_bloom);
8932                 r_bloomstate.texture_bloom = NULL;
8933                 r_bloomstate.bloomtexturewidth = bloomtexturewidth;
8934                 r_bloomstate.bloomtextureheight = bloomtextureheight;
8935                 if (r_bloomstate.bloomtexturewidth && r_bloomstate.bloomtextureheight)
8936                         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);
8937         }
8938
8939         // when doing a reduced render (HDR) we want to use a smaller area
8940         r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, r_refdef.view.height);
8941         r_bloomstate.bloomheight = r_bloomstate.bloomwidth * r_refdef.view.height / r_refdef.view.width;
8942         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_refdef.view.height);
8943         r_bloomstate.bloomwidth = bound(1, r_bloomstate.bloomwidth, r_bloomstate.bloomtexturewidth);
8944         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_bloomstate.bloomtextureheight);
8945
8946         // set up a texcoord array for the full resolution screen image
8947         // (we have to keep this around to copy back during final render)
8948         r_bloomstate.screentexcoord2f[0] = 0;
8949         r_bloomstate.screentexcoord2f[1] = (float)r_refdef.view.height    / (float)r_bloomstate.screentextureheight;
8950         r_bloomstate.screentexcoord2f[2] = (float)r_refdef.view.width     / (float)r_bloomstate.screentexturewidth;
8951         r_bloomstate.screentexcoord2f[3] = (float)r_refdef.view.height    / (float)r_bloomstate.screentextureheight;
8952         r_bloomstate.screentexcoord2f[4] = (float)r_refdef.view.width     / (float)r_bloomstate.screentexturewidth;
8953         r_bloomstate.screentexcoord2f[5] = 0;
8954         r_bloomstate.screentexcoord2f[6] = 0;
8955         r_bloomstate.screentexcoord2f[7] = 0;
8956
8957         // set up a texcoord array for the reduced resolution bloom image
8958         // (which will be additive blended over the screen image)
8959         r_bloomstate.bloomtexcoord2f[0] = 0;
8960         r_bloomstate.bloomtexcoord2f[1] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
8961         r_bloomstate.bloomtexcoord2f[2] = (float)r_bloomstate.bloomwidth  / (float)r_bloomstate.bloomtexturewidth;
8962         r_bloomstate.bloomtexcoord2f[3] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
8963         r_bloomstate.bloomtexcoord2f[4] = (float)r_bloomstate.bloomwidth  / (float)r_bloomstate.bloomtexturewidth;
8964         r_bloomstate.bloomtexcoord2f[5] = 0;
8965         r_bloomstate.bloomtexcoord2f[6] = 0;
8966         r_bloomstate.bloomtexcoord2f[7] = 0;
8967
8968         switch(vid.renderpath)
8969         {
8970         case RENDERPATH_GL11:
8971         case RENDERPATH_GL13:
8972         case RENDERPATH_GL20:
8973         case RENDERPATH_CGGL:
8974                 break;
8975         case RENDERPATH_D3D9:
8976         case RENDERPATH_D3D10:
8977         case RENDERPATH_D3D11:
8978                 {
8979                         int i;
8980                         for (i = 0;i < 4;i++)
8981                         {
8982                                 r_bloomstate.screentexcoord2f[i*2+0] += 0.5f / (float)r_bloomstate.screentexturewidth;
8983                                 r_bloomstate.screentexcoord2f[i*2+1] += 0.5f / (float)r_bloomstate.screentextureheight;
8984                                 r_bloomstate.bloomtexcoord2f[i*2+0] += 0.5f / (float)r_bloomstate.bloomtexturewidth;
8985                                 r_bloomstate.bloomtexcoord2f[i*2+1] += 0.5f / (float)r_bloomstate.bloomtextureheight;
8986                         }
8987                 }
8988                 break;
8989         }
8990
8991         if (r_hdr.integer || r_bloom.integer)
8992         {
8993                 r_bloomstate.enabled = true;
8994                 r_bloomstate.hdr = r_hdr.integer != 0;
8995         }
8996
8997         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);
8998 }
8999
9000 void R_Bloom_CopyBloomTexture(float colorscale)
9001 {
9002         r_refdef.stats.bloom++;
9003
9004         // scale down screen texture to the bloom texture size
9005         CHECKGLERROR
9006         R_SetViewport(&r_bloomstate.viewport);
9007         GL_BlendFunc(GL_ONE, GL_ZERO);
9008         GL_Color(colorscale, colorscale, colorscale, 1);
9009         // 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...
9010         switch(vid.renderpath)
9011         {
9012         case RENDERPATH_GL11:
9013         case RENDERPATH_GL13:
9014         case RENDERPATH_GL20:
9015         case RENDERPATH_CGGL:
9016                 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_bloomstate.screentexcoord2f);
9017                 break;
9018         case RENDERPATH_D3D9:
9019         case RENDERPATH_D3D10:
9020         case RENDERPATH_D3D11:
9021                 R_Mesh_PrepareVertices_Generic_Arrays(4, r_d3dscreenvertex3f, NULL, r_bloomstate.screentexcoord2f);
9022                 break;
9023         }
9024         // TODO: do boxfilter scale-down in shader?
9025         R_SetupShader_Generic(r_bloomstate.texture_screen, NULL, GL_MODULATE, 1);
9026         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
9027         r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
9028
9029         // we now have a bloom image in the framebuffer
9030         // copy it into the bloom image texture for later processing
9031         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);
9032         r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
9033 }
9034
9035 void R_Bloom_CopyHDRTexture(void)
9036 {
9037         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);
9038         r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
9039 }
9040
9041 void R_Bloom_MakeTexture(void)
9042 {
9043         int x, range, dir;
9044         float xoffset, yoffset, r, brighten;
9045
9046         r_refdef.stats.bloom++;
9047
9048         R_ResetViewRendering2D();
9049
9050         // we have a bloom image in the framebuffer
9051         CHECKGLERROR
9052         R_SetViewport(&r_bloomstate.viewport);
9053
9054         for (x = 1;x < min(r_bloom_colorexponent.value, 32);)
9055         {
9056                 x *= 2;
9057                 r = bound(0, r_bloom_colorexponent.value / x, 1);
9058                 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
9059                 GL_Color(r,r,r,1);
9060                 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_bloomstate.bloomtexcoord2f);
9061                 R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
9062                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
9063                 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
9064
9065                 // copy the vertically blurred bloom view to a texture
9066                 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);
9067                 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
9068         }
9069
9070         range = r_bloom_blur.integer * r_bloomstate.bloomwidth / 320;
9071         brighten = r_bloom_brighten.value;
9072         if (r_hdr.integer)
9073                 brighten *= r_hdr_range.value;
9074         brighten = sqrt(brighten);
9075         if(range >= 1)
9076                 brighten *= (3 * range) / (2 * range - 1); // compensate for the "dot particle"
9077         R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
9078
9079         for (dir = 0;dir < 2;dir++)
9080         {
9081                 // blend on at multiple vertical offsets to achieve a vertical blur
9082                 // TODO: do offset blends using GLSL
9083                 // TODO instead of changing the texcoords, change the target positions to prevent artifacts at edges
9084                 GL_BlendFunc(GL_ONE, GL_ZERO);
9085                 for (x = -range;x <= range;x++)
9086                 {
9087                         if (!dir){xoffset = 0;yoffset = x;}
9088                         else {xoffset = x;yoffset = 0;}
9089                         xoffset /= (float)r_bloomstate.bloomtexturewidth;
9090                         yoffset /= (float)r_bloomstate.bloomtextureheight;
9091                         // compute a texcoord array with the specified x and y offset
9092                         r_bloomstate.offsettexcoord2f[0] = xoffset+0;
9093                         r_bloomstate.offsettexcoord2f[1] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
9094                         r_bloomstate.offsettexcoord2f[2] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
9095                         r_bloomstate.offsettexcoord2f[3] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
9096                         r_bloomstate.offsettexcoord2f[4] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
9097                         r_bloomstate.offsettexcoord2f[5] = yoffset+0;
9098                         r_bloomstate.offsettexcoord2f[6] = xoffset+0;
9099                         r_bloomstate.offsettexcoord2f[7] = yoffset+0;
9100                         // this r value looks like a 'dot' particle, fading sharply to
9101                         // black at the edges
9102                         // (probably not realistic but looks good enough)
9103                         //r = ((range*range+1)/((float)(x*x+1)))/(range*2+1);
9104                         //r = brighten/(range*2+1);
9105                         r = brighten / (range * 2 + 1);
9106                         if(range >= 1)
9107                                 r *= (1 - x*x/(float)(range*range));
9108                         GL_Color(r, r, r, 1);
9109                         R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_bloomstate.offsettexcoord2f);
9110                         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
9111                         r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
9112                         GL_BlendFunc(GL_ONE, GL_ONE);
9113                 }
9114
9115                 // copy the vertically blurred bloom view to a texture
9116                 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);
9117                 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
9118         }
9119 }
9120
9121 void R_HDR_RenderBloomTexture(void)
9122 {
9123         int oldwidth, oldheight;
9124         float oldcolorscale;
9125
9126         oldcolorscale = r_refdef.view.colorscale;
9127         oldwidth = r_refdef.view.width;
9128         oldheight = r_refdef.view.height;
9129         r_refdef.view.width = r_bloomstate.bloomwidth;
9130         r_refdef.view.height = r_bloomstate.bloomheight;
9131
9132         // TODO: support GL_EXT_framebuffer_object rather than reusing the framebuffer?  it might improve SLI performance.
9133         // TODO: add exposure compensation features
9134         // TODO: add fp16 framebuffer support (using GL_EXT_framebuffer_object)
9135
9136         r_refdef.view.showdebug = false;
9137         r_refdef.view.colorscale *= r_bloom_colorscale.value / bound(1, r_hdr_range.value, 16);
9138
9139         R_ResetViewRendering3D();
9140
9141         R_ClearScreen(r_refdef.fogenabled);
9142         if (r_timereport_active)
9143                 R_TimeReport("HDRclear");
9144
9145         R_View_Update();
9146         if (r_timereport_active)
9147                 R_TimeReport("visibility");
9148
9149         // only do secondary renders with HDR if r_hdr is 2 or higher
9150         r_waterstate.numwaterplanes = 0;
9151         if (r_waterstate.enabled && r_hdr.integer >= 2)
9152                 R_RenderWaterPlanes();
9153
9154         r_refdef.view.showdebug = true;
9155         R_RenderScene();
9156         r_waterstate.numwaterplanes = 0;
9157
9158         R_ResetViewRendering2D();
9159
9160         R_Bloom_CopyHDRTexture();
9161         R_Bloom_MakeTexture();
9162
9163         // restore the view settings
9164         r_refdef.view.width = oldwidth;
9165         r_refdef.view.height = oldheight;
9166         r_refdef.view.colorscale = oldcolorscale;
9167
9168         R_ResetViewRendering3D();
9169
9170         R_ClearScreen(r_refdef.fogenabled);
9171         if (r_timereport_active)
9172                 R_TimeReport("viewclear");
9173 }
9174
9175 static void R_BlendView(void)
9176 {
9177         unsigned int permutation;
9178         float uservecs[4][4];
9179
9180         switch (vid.renderpath)
9181         {
9182         case RENDERPATH_GL20:
9183         case RENDERPATH_CGGL:
9184         case RENDERPATH_D3D9:
9185         case RENDERPATH_D3D10:
9186         case RENDERPATH_D3D11:
9187                 permutation =
9188                           (r_bloomstate.texture_bloom ? SHADERPERMUTATION_BLOOM : 0)
9189                         | (r_refdef.viewblend[3] > 0 ? SHADERPERMUTATION_VIEWTINT : 0)
9190                         | ((v_glslgamma.value && !vid_gammatables_trivial) ? SHADERPERMUTATION_GAMMARAMPS : 0)
9191                         | (r_glsl_postprocess.integer ? SHADERPERMUTATION_POSTPROCESSING : 0)
9192                         | ((!R_Stereo_ColorMasking() && r_glsl_saturation.value != 1) ? SHADERPERMUTATION_SATURATION : 0);
9193
9194                 if (r_bloomstate.texture_screen)
9195                 {
9196                         // make sure the buffer is available
9197                         if (r_bloom_blur.value < 1) { Cvar_SetValueQuick(&r_bloom_blur, 1); }
9198
9199                         R_ResetViewRendering2D();
9200
9201                         if(!R_Stereo_Active() && (r_motionblur.value > 0 || r_damageblur.value > 0))
9202                         {
9203                                 // declare variables
9204                                 float speed;
9205                                 static float avgspeed;
9206
9207                                 speed = VectorLength(cl.movement_velocity);
9208
9209                                 cl.motionbluralpha = bound(0, (cl.time - cl.oldtime) / max(0.001, r_motionblur_vcoeff.value), 1);
9210                                 avgspeed = avgspeed * (1 - cl.motionbluralpha) + speed * cl.motionbluralpha;
9211
9212                                 speed = (avgspeed - r_motionblur_vmin.value) / max(1, r_motionblur_vmax.value - r_motionblur_vmin.value);
9213                                 speed = bound(0, speed, 1);
9214                                 speed = speed * (1 - r_motionblur_bmin.value) + r_motionblur_bmin.value;
9215
9216                                 // calculate values into a standard alpha
9217                                 cl.motionbluralpha = 1 - exp(-
9218                                                 (
9219                                                  (r_motionblur.value * speed / 80)
9220                                                  +
9221                                                  (r_damageblur.value * (cl.cshifts[CSHIFT_DAMAGE].percent / 1600))
9222                                                 )
9223                                                 /
9224                                                 max(0.0001, cl.time - cl.oldtime) // fps independent
9225                                            );
9226
9227                                 cl.motionbluralpha *= lhrandom(1 - r_motionblur_randomize.value, 1 + r_motionblur_randomize.value);
9228                                 cl.motionbluralpha = bound(0, cl.motionbluralpha, r_motionblur_maxblur.value);
9229                                 // apply the blur
9230                                 if (cl.motionbluralpha > 0 && !r_refdef.envmap)
9231                                 {
9232                                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
9233                                         GL_Color(1, 1, 1, cl.motionbluralpha);
9234                                         switch(vid.renderpath)
9235                                         {
9236                                         case RENDERPATH_GL11:
9237                                         case RENDERPATH_GL13:
9238                                         case RENDERPATH_GL20:
9239                                         case RENDERPATH_CGGL:
9240                                                 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_bloomstate.screentexcoord2f);
9241                                                 break;
9242                                         case RENDERPATH_D3D9:
9243                                         case RENDERPATH_D3D10:
9244                                         case RENDERPATH_D3D11:
9245                                                 R_Mesh_PrepareVertices_Generic_Arrays(4, r_d3dscreenvertex3f, NULL, r_bloomstate.screentexcoord2f);
9246                                                 break;
9247                                         }
9248                                         R_SetupShader_Generic(r_bloomstate.texture_screen, NULL, GL_MODULATE, 1);
9249                                         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
9250                                         r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
9251                                 }
9252                         }
9253
9254                         // copy view into the screen texture
9255                         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);
9256                         r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
9257                 }
9258                 else if (!r_bloomstate.texture_bloom)
9259                 {
9260                         // we may still have to do view tint...
9261                         if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
9262                         {
9263                                 // apply a color tint to the whole view
9264                                 R_ResetViewRendering2D();
9265                                 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
9266                                 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, NULL);
9267                                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9268                                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
9269                                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
9270                         }
9271                         break; // no screen processing, no bloom, skip it
9272                 }
9273
9274                 if (r_bloomstate.texture_bloom && !r_bloomstate.hdr)
9275                 {
9276                         // render simple bloom effect
9277                         // copy the screen and shrink it and darken it for the bloom process
9278                         R_Bloom_CopyBloomTexture(r_bloom_colorscale.value);
9279                         // make the bloom texture
9280                         R_Bloom_MakeTexture();
9281                 }
9282
9283 #if _MSC_VER >= 1400
9284 #define sscanf sscanf_s
9285 #endif
9286                 memset(uservecs, 0, sizeof(uservecs));
9287                 sscanf(r_glsl_postprocess_uservec1.string, "%f %f %f %f", &uservecs[0][0], &uservecs[0][1], &uservecs[0][2], &uservecs[0][3]);
9288                 sscanf(r_glsl_postprocess_uservec2.string, "%f %f %f %f", &uservecs[1][0], &uservecs[1][1], &uservecs[1][2], &uservecs[1][3]);
9289                 sscanf(r_glsl_postprocess_uservec3.string, "%f %f %f %f", &uservecs[2][0], &uservecs[2][1], &uservecs[2][2], &uservecs[2][3]);
9290                 sscanf(r_glsl_postprocess_uservec4.string, "%f %f %f %f", &uservecs[3][0], &uservecs[3][1], &uservecs[3][2], &uservecs[3][3]);
9291
9292                 R_ResetViewRendering2D();
9293                 GL_Color(1, 1, 1, 1);
9294                 GL_BlendFunc(GL_ONE, GL_ZERO);
9295
9296                 switch(vid.renderpath)
9297                 {
9298                 case RENDERPATH_GL20:
9299                         R_Mesh_PrepareVertices_Mesh_Arrays(4, r_screenvertex3f, NULL, NULL, NULL, NULL, r_bloomstate.screentexcoord2f, r_bloomstate.bloomtexcoord2f);
9300                         R_SetupShader_SetPermutationGLSL(SHADERMODE_POSTPROCESS, permutation);
9301                         if (r_glsl_permutation->loc_Texture_First      >= 0) R_Mesh_TexBind(GL20TU_FIRST     , r_bloomstate.texture_screen);
9302                         if (r_glsl_permutation->loc_Texture_Second     >= 0) R_Mesh_TexBind(GL20TU_SECOND    , r_bloomstate.texture_bloom );
9303                         if (r_glsl_permutation->loc_Texture_GammaRamps >= 0) R_Mesh_TexBind(GL20TU_GAMMARAMPS, r_texture_gammaramps       );
9304                         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]);
9305                         if (r_glsl_permutation->loc_PixelSize          >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelSize         , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);
9306                         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]);
9307                         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]);
9308                         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]);
9309                         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]);
9310                         if (r_glsl_permutation->loc_Saturation         >= 0) qglUniform1fARB(r_glsl_permutation->loc_Saturation        , r_glsl_saturation.value);
9311                         if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
9312                         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);
9313                         break;
9314                 case RENDERPATH_CGGL:
9315 #ifdef SUPPORTCG
9316                         R_Mesh_PrepareVertices_Mesh_Arrays(4, r_screenvertex3f, NULL, NULL, NULL, NULL, r_bloomstate.screentexcoord2f, r_bloomstate.bloomtexcoord2f);
9317                         R_SetupShader_SetPermutationCG(SHADERMODE_POSTPROCESS, permutation);
9318                         if (r_cg_permutation->fp_Texture_First     ) CG_BindTexture(r_cg_permutation->fp_Texture_First     , r_bloomstate.texture_screen);CHECKCGERROR
9319                         if (r_cg_permutation->fp_Texture_Second    ) CG_BindTexture(r_cg_permutation->fp_Texture_Second    , r_bloomstate.texture_bloom );CHECKCGERROR
9320                         if (r_cg_permutation->fp_Texture_GammaRamps) CG_BindTexture(r_cg_permutation->fp_Texture_GammaRamps, r_texture_gammaramps       );CHECKCGERROR
9321                         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
9322                         if (r_cg_permutation->fp_PixelSize         ) cgGLSetParameter2f(     r_cg_permutation->fp_PixelSize         , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);CHECKCGERROR
9323                         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
9324                         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
9325                         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
9326                         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
9327                         if (r_cg_permutation->fp_Saturation        ) cgGLSetParameter1f(     r_cg_permutation->fp_Saturation        , r_glsl_saturation.value);CHECKCGERROR
9328                         if (r_cg_permutation->fp_PixelToScreenTexCoord) cgGLSetParameter2f(r_cg_permutation->fp_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);CHECKCGERROR
9329                         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);
9330 #endif
9331                         break;
9332                 case RENDERPATH_D3D9:
9333 #ifdef SUPPORTD3D
9334                         // 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...
9335                         R_Mesh_PrepareVertices_Mesh_Arrays(4, r_d3dscreenvertex3f, NULL, NULL, NULL, NULL, r_bloomstate.screentexcoord2f, r_bloomstate.bloomtexcoord2f);
9336                         R_SetupShader_SetPermutationHLSL(SHADERMODE_POSTPROCESS, permutation);
9337                         R_Mesh_TexBind(GL20TU_FIRST     , r_bloomstate.texture_screen);
9338                         R_Mesh_TexBind(GL20TU_SECOND    , r_bloomstate.texture_bloom );
9339                         R_Mesh_TexBind(GL20TU_GAMMARAMPS, r_texture_gammaramps       );
9340                         hlslPSSetParameter4f(D3DPSREGISTER_ViewTintColor        , r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
9341                         hlslPSSetParameter2f(D3DPSREGISTER_PixelSize            , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);
9342                         hlslPSSetParameter4f(D3DPSREGISTER_UserVec1             , uservecs[0][0], uservecs[0][1], uservecs[0][2], uservecs[0][3]);
9343                         hlslPSSetParameter4f(D3DPSREGISTER_UserVec2             , uservecs[1][0], uservecs[1][1], uservecs[1][2], uservecs[1][3]);
9344                         hlslPSSetParameter4f(D3DPSREGISTER_UserVec3             , uservecs[2][0], uservecs[2][1], uservecs[2][2], uservecs[2][3]);
9345                         hlslPSSetParameter4f(D3DPSREGISTER_UserVec4             , uservecs[3][0], uservecs[3][1], uservecs[3][2], uservecs[3][3]);
9346                         hlslPSSetParameter1f(D3DPSREGISTER_Saturation           , r_glsl_saturation.value);
9347                         hlslPSSetParameter2f(D3DPSREGISTER_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);
9348                         hlslPSSetParameter4f(D3DPSREGISTER_BloomColorSubtract   , r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 0.0f);
9349 #endif
9350                         break;
9351                 case RENDERPATH_D3D10:
9352                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
9353                         break;
9354                 case RENDERPATH_D3D11:
9355                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
9356                         break;
9357                 default:
9358                         break;
9359                 }
9360                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
9361                 r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
9362                 break;
9363         case RENDERPATH_GL13:
9364         case RENDERPATH_GL11:
9365                 if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
9366                 {
9367                         // apply a color tint to the whole view
9368                         R_ResetViewRendering2D();
9369                         GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
9370                         R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, NULL);
9371                         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9372                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
9373                         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
9374                 }
9375                 break;
9376         }
9377 }
9378
9379 matrix4x4_t r_waterscrollmatrix;
9380
9381 void R_UpdateFogColor(void) // needs to be called before HDR subrender too, as that changes colorscale!
9382 {
9383         if (r_refdef.fog_density)
9384         {
9385                 r_refdef.fogcolor[0] = r_refdef.fog_red;
9386                 r_refdef.fogcolor[1] = r_refdef.fog_green;
9387                 r_refdef.fogcolor[2] = r_refdef.fog_blue;
9388
9389                 Vector4Set(r_refdef.fogplane, 0, 0, 1, -r_refdef.fog_height);
9390                 r_refdef.fogplaneviewdist = DotProduct(r_refdef.fogplane, r_refdef.view.origin) + r_refdef.fogplane[3];
9391                 r_refdef.fogplaneviewabove = r_refdef.fogplaneviewdist >= 0;
9392                 r_refdef.fogheightfade = -0.5f/max(0.125f, r_refdef.fog_fadedepth);
9393
9394                 {
9395                         vec3_t fogvec;
9396                         VectorCopy(r_refdef.fogcolor, fogvec);
9397                         //   color.rgb *= ContrastBoost * SceneBrightness;
9398                         VectorScale(fogvec, r_refdef.view.colorscale, fogvec);
9399                         r_refdef.fogcolor[0] = bound(0.0f, fogvec[0], 1.0f);
9400                         r_refdef.fogcolor[1] = bound(0.0f, fogvec[1], 1.0f);
9401                         r_refdef.fogcolor[2] = bound(0.0f, fogvec[2], 1.0f);
9402                 }
9403         }
9404 }
9405
9406 void R_UpdateVariables(void)
9407 {
9408         R_Textures_Frame();
9409
9410         r_refdef.scene.ambient = r_ambient.value * (1.0f / 64.0f);
9411
9412         r_refdef.farclip = r_farclip_base.value;
9413         if (r_refdef.scene.worldmodel)
9414                 r_refdef.farclip += r_refdef.scene.worldmodel->radius * r_farclip_world.value * 2;
9415         r_refdef.nearclip = bound (0.001f, r_nearclip.value, r_refdef.farclip - 1.0f);
9416
9417         if (r_shadow_frontsidecasting.integer < 0 || r_shadow_frontsidecasting.integer > 1)
9418                 Cvar_SetValueQuick(&r_shadow_frontsidecasting, 1);
9419         r_refdef.polygonfactor = 0;
9420         r_refdef.polygonoffset = 0;
9421         r_refdef.shadowpolygonfactor = r_refdef.polygonfactor + r_shadow_polygonfactor.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
9422         r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_polygonoffset.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
9423
9424         r_refdef.scene.rtworld = r_shadow_realtime_world.integer != 0;
9425         r_refdef.scene.rtworldshadows = r_shadow_realtime_world_shadows.integer && vid.stencil;
9426         r_refdef.scene.rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer && r_dynamic.integer;
9427         r_refdef.scene.rtdlightshadows = r_refdef.scene.rtdlight && r_shadow_realtime_dlight_shadows.integer && vid.stencil;
9428         r_refdef.lightmapintensity = r_refdef.scene.rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
9429         if (FAKELIGHT_ENABLED)
9430         {
9431                 r_refdef.lightmapintensity *= r_fakelight_intensity.value;
9432         }
9433         if (r_showsurfaces.integer)
9434         {
9435                 r_refdef.scene.rtworld = false;
9436                 r_refdef.scene.rtworldshadows = false;
9437                 r_refdef.scene.rtdlight = false;
9438                 r_refdef.scene.rtdlightshadows = false;
9439                 r_refdef.lightmapintensity = 0;
9440         }
9441
9442         if (gamemode == GAME_NEHAHRA)
9443         {
9444                 if (gl_fogenable.integer)
9445                 {
9446                         r_refdef.oldgl_fogenable = true;
9447                         r_refdef.fog_density = gl_fogdensity.value;
9448                         r_refdef.fog_red = gl_fogred.value;
9449                         r_refdef.fog_green = gl_foggreen.value;
9450                         r_refdef.fog_blue = gl_fogblue.value;
9451                         r_refdef.fog_alpha = 1;
9452                         r_refdef.fog_start = 0;
9453                         r_refdef.fog_end = gl_skyclip.value;
9454                         r_refdef.fog_height = 1<<30;
9455                         r_refdef.fog_fadedepth = 128;
9456                 }
9457                 else if (r_refdef.oldgl_fogenable)
9458                 {
9459                         r_refdef.oldgl_fogenable = false;
9460                         r_refdef.fog_density = 0;
9461                         r_refdef.fog_red = 0;
9462                         r_refdef.fog_green = 0;
9463                         r_refdef.fog_blue = 0;
9464                         r_refdef.fog_alpha = 0;
9465                         r_refdef.fog_start = 0;
9466                         r_refdef.fog_end = 0;
9467                         r_refdef.fog_height = 1<<30;
9468                         r_refdef.fog_fadedepth = 128;
9469                 }
9470         }
9471
9472         r_refdef.fog_alpha = bound(0, r_refdef.fog_alpha, 1);
9473         r_refdef.fog_start = max(0, r_refdef.fog_start);
9474         r_refdef.fog_end = max(r_refdef.fog_start + 0.01, r_refdef.fog_end);
9475
9476         // R_UpdateFogColor(); // why? R_RenderScene does it anyway
9477
9478         if (r_refdef.fog_density && r_drawfog.integer)
9479         {
9480                 r_refdef.fogenabled = true;
9481                 // this is the point where the fog reaches 0.9986 alpha, which we
9482                 // consider a good enough cutoff point for the texture
9483                 // (0.9986 * 256 == 255.6)
9484                 if (r_fog_exp2.integer)
9485                         r_refdef.fogrange = 32 / (r_refdef.fog_density * r_refdef.fog_density) + r_refdef.fog_start;
9486                 else
9487                         r_refdef.fogrange = 2048 / r_refdef.fog_density + r_refdef.fog_start;
9488                 r_refdef.fogrange = bound(r_refdef.fog_start, r_refdef.fogrange, r_refdef.fog_end);
9489                 r_refdef.fograngerecip = 1.0f / r_refdef.fogrange;
9490                 r_refdef.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * r_refdef.fograngerecip;
9491                 if (strcmp(r_refdef.fogheighttexturename, r_refdef.fog_height_texturename))
9492                         R_BuildFogHeightTexture();
9493                 // fog color was already set
9494                 // update the fog texture
9495                 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)
9496                         R_BuildFogTexture();
9497                 r_refdef.fog_height_texcoordscale = 1.0f / max(0.125f, r_refdef.fog_fadedepth);
9498                 r_refdef.fog_height_tablescale = r_refdef.fog_height_tablesize * r_refdef.fog_height_texcoordscale;
9499         }
9500         else
9501                 r_refdef.fogenabled = false;
9502
9503         switch(vid.renderpath)
9504         {
9505         case RENDERPATH_GL20:
9506         case RENDERPATH_CGGL:
9507         case RENDERPATH_D3D9:
9508         case RENDERPATH_D3D10:
9509         case RENDERPATH_D3D11:
9510                 if(v_glslgamma.integer && !vid_gammatables_trivial)
9511                 {
9512                         if(!r_texture_gammaramps || vid_gammatables_serial != r_texture_gammaramps_serial)
9513                         {
9514                                 // build GLSL gamma texture
9515 #define RAMPWIDTH 256
9516                                 unsigned short ramp[RAMPWIDTH * 3];
9517                                 unsigned char rampbgr[RAMPWIDTH][4];
9518                                 int i;
9519
9520                                 r_texture_gammaramps_serial = vid_gammatables_serial;
9521
9522                                 VID_BuildGammaTables(&ramp[0], RAMPWIDTH);
9523                                 for(i = 0; i < RAMPWIDTH; ++i)
9524                                 {
9525                                         rampbgr[i][0] = (unsigned char) (ramp[i + 2 * RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
9526                                         rampbgr[i][1] = (unsigned char) (ramp[i + RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
9527                                         rampbgr[i][2] = (unsigned char) (ramp[i] * 255.0 / 65535.0 + 0.5);
9528                                         rampbgr[i][3] = 0;
9529                                 }
9530                                 if (r_texture_gammaramps)
9531                                 {
9532                                         R_UpdateTexture(r_texture_gammaramps, &rampbgr[0][0], 0, 0, RAMPWIDTH, 1);
9533                                 }
9534                                 else
9535                                 {
9536                                         r_texture_gammaramps = R_LoadTexture2D(r_main_texturepool, "gammaramps", RAMPWIDTH, 1, &rampbgr[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL);
9537                                 }
9538                         }
9539                 }
9540                 else
9541                 {
9542                         // remove GLSL gamma texture
9543                 }
9544                 break;
9545         case RENDERPATH_GL13:
9546         case RENDERPATH_GL11:
9547                 break;
9548         }
9549 }
9550
9551 static r_refdef_scene_type_t r_currentscenetype = RST_CLIENT;
9552 static r_refdef_scene_t r_scenes_store[ RST_COUNT ];
9553 /*
9554 ================
9555 R_SelectScene
9556 ================
9557 */
9558 void R_SelectScene( r_refdef_scene_type_t scenetype ) {
9559         if( scenetype != r_currentscenetype ) {
9560                 // store the old scenetype
9561                 r_scenes_store[ r_currentscenetype ] = r_refdef.scene;
9562                 r_currentscenetype = scenetype;
9563                 // move in the new scene
9564                 r_refdef.scene = r_scenes_store[ r_currentscenetype ];
9565         }
9566 }
9567
9568 /*
9569 ================
9570 R_GetScenePointer
9571 ================
9572 */
9573 r_refdef_scene_t * R_GetScenePointer( r_refdef_scene_type_t scenetype )
9574 {
9575         // of course, we could also add a qboolean that provides a lock state and a ReleaseScenePointer function..
9576         if( scenetype == r_currentscenetype ) {
9577                 return &r_refdef.scene;
9578         } else {
9579                 return &r_scenes_store[ scenetype ];
9580         }
9581 }
9582
9583 /*
9584 ================
9585 R_RenderView
9586 ================
9587 */
9588 void R_RenderView(void)
9589 {
9590         if (r_timereport_active)
9591                 R_TimeReport("start");
9592         r_textureframe++; // used only by R_GetCurrentTexture
9593         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
9594
9595         if(R_CompileShader_CheckStaticParms())
9596                 R_GLSL_Restart_f();
9597
9598         if (!r_drawentities.integer)
9599                 r_refdef.scene.numentities = 0;
9600
9601         R_AnimCache_ClearCache();
9602         R_FrameData_NewFrame();
9603
9604         if (r_refdef.view.isoverlay)
9605         {
9606                 // TODO: FIXME: move this into its own backend function maybe? [2/5/2008 Andreas]
9607                 GL_Clear(GL_DEPTH_BUFFER_BIT, NULL, 1.0f, 0);
9608                 R_TimeReport("depthclear");
9609
9610                 r_refdef.view.showdebug = false;
9611
9612                 r_waterstate.enabled = false;
9613                 r_waterstate.numwaterplanes = 0;
9614
9615                 R_RenderScene();
9616
9617                 CHECKGLERROR
9618                 return;
9619         }
9620
9621         if (!r_refdef.scene.entities || r_refdef.view.width * r_refdef.view.height == 0 || !r_renderview.integer || cl_videoplaying/* || !r_refdef.scene.worldmodel*/)
9622                 return; //Host_Error ("R_RenderView: NULL worldmodel");
9623
9624         r_refdef.view.colorscale = r_hdr_scenebrightness.value;
9625
9626         R_RenderView_UpdateViewVectors();
9627
9628         R_Shadow_UpdateWorldLightSelection();
9629
9630         R_Bloom_StartFrame();
9631         R_Water_StartFrame();
9632
9633         CHECKGLERROR
9634         if (r_timereport_active)
9635                 R_TimeReport("viewsetup");
9636
9637         R_ResetViewRendering3D();
9638
9639         if (r_refdef.view.clear || r_refdef.fogenabled)
9640         {
9641                 R_ClearScreen(r_refdef.fogenabled);
9642                 if (r_timereport_active)
9643                         R_TimeReport("viewclear");
9644         }
9645         r_refdef.view.clear = true;
9646
9647         // this produces a bloom texture to be used in R_BlendView() later
9648         if (r_hdr.integer && r_bloomstate.bloomwidth)
9649         {
9650                 R_HDR_RenderBloomTexture();
9651                 // we have to bump the texture frame again because r_refdef.view.colorscale is cached in the textures
9652                 r_textureframe++; // used only by R_GetCurrentTexture
9653         }
9654
9655         r_refdef.view.showdebug = true;
9656
9657         R_View_Update();
9658         if (r_timereport_active)
9659                 R_TimeReport("visibility");
9660
9661         r_waterstate.numwaterplanes = 0;
9662         if (r_waterstate.enabled)
9663                 R_RenderWaterPlanes();
9664
9665         R_RenderScene();
9666         r_waterstate.numwaterplanes = 0;
9667
9668         R_BlendView();
9669         if (r_timereport_active)
9670                 R_TimeReport("blendview");
9671
9672         GL_Scissor(0, 0, vid.width, vid.height);
9673         GL_ScissorTest(false);
9674
9675         CHECKGLERROR
9676 }
9677
9678 void R_RenderWaterPlanes(void)
9679 {
9680         if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawAddWaterPlanes)
9681         {
9682                 r_refdef.scene.worldmodel->DrawAddWaterPlanes(r_refdef.scene.worldentity);
9683                 if (r_timereport_active)
9684                         R_TimeReport("waterworld");
9685         }
9686
9687         // don't let sound skip if going slow
9688         if (r_refdef.scene.extraupdate)
9689                 S_ExtraUpdate ();
9690
9691         R_DrawModelsAddWaterPlanes();
9692         if (r_timereport_active)
9693                 R_TimeReport("watermodels");
9694
9695         if (r_waterstate.numwaterplanes)
9696         {
9697                 R_Water_ProcessPlanes();
9698                 if (r_timereport_active)
9699                         R_TimeReport("waterscenes");
9700         }
9701 }
9702
9703 extern void R_DrawLightningBeams (void);
9704 extern void VM_CL_AddPolygonsToMeshQueue (void);
9705 extern void R_DrawPortals (void);
9706 extern cvar_t cl_locs_show;
9707 static void R_DrawLocs(void);
9708 static void R_DrawEntityBBoxes(void);
9709 static void R_DrawModelDecals(void);
9710 extern void R_DrawModelShadows(void);
9711 extern void R_DrawModelShadowMaps(void);
9712 extern cvar_t cl_decals_newsystem;
9713 extern qboolean r_shadow_usingdeferredprepass;
9714 void R_RenderScene(void)
9715 {
9716         qboolean shadowmapping = false;
9717
9718         if (r_timereport_active)
9719                 R_TimeReport("beginscene");
9720
9721         r_refdef.stats.renders++;
9722
9723         R_UpdateFogColor();
9724
9725         // don't let sound skip if going slow
9726         if (r_refdef.scene.extraupdate)
9727                 S_ExtraUpdate ();
9728
9729         R_MeshQueue_BeginScene();
9730
9731         R_SkyStartFrame();
9732
9733         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);
9734
9735         if (r_timereport_active)
9736                 R_TimeReport("skystartframe");
9737
9738         if (cl.csqc_vidvars.drawworld)
9739         {
9740                 // don't let sound skip if going slow
9741                 if (r_refdef.scene.extraupdate)
9742                         S_ExtraUpdate ();
9743
9744                 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawSky)
9745                 {
9746                         r_refdef.scene.worldmodel->DrawSky(r_refdef.scene.worldentity);
9747                         if (r_timereport_active)
9748                                 R_TimeReport("worldsky");
9749                 }
9750
9751                 if (R_DrawBrushModelsSky() && r_timereport_active)
9752                         R_TimeReport("bmodelsky");
9753
9754                 if (skyrendermasked && skyrenderlater)
9755                 {
9756                         // we have to force off the water clipping plane while rendering sky
9757                         R_SetupView(false);
9758                         R_Sky();
9759                         R_SetupView(true);
9760                         if (r_timereport_active)
9761                                 R_TimeReport("sky");
9762                 }
9763         }
9764
9765         R_AnimCache_CacheVisibleEntities();
9766         if (r_timereport_active)
9767                 R_TimeReport("animation");
9768
9769         R_Shadow_PrepareLights();
9770         if (r_shadows.integer > 0 && r_refdef.lightmapintensity > 0)
9771                 R_Shadow_PrepareModelShadows();
9772         if (r_timereport_active)
9773                 R_TimeReport("preparelights");
9774
9775         if (R_Shadow_ShadowMappingEnabled())
9776                 shadowmapping = true;
9777
9778         if (r_shadow_usingdeferredprepass)
9779                 R_Shadow_DrawPrepass();
9780
9781         if (r_depthfirst.integer >= 1 && cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawDepth)
9782         {
9783                 r_refdef.scene.worldmodel->DrawDepth(r_refdef.scene.worldentity);
9784                 if (r_timereport_active)
9785                         R_TimeReport("worlddepth");
9786         }
9787         if (r_depthfirst.integer >= 2)
9788         {
9789                 R_DrawModelsDepth();
9790                 if (r_timereport_active)
9791                         R_TimeReport("modeldepth");
9792         }
9793
9794         if (r_shadows.integer >= 2 && shadowmapping && r_refdef.lightmapintensity > 0)
9795         {
9796                 R_DrawModelShadowMaps();
9797                 R_ResetViewRendering3D();
9798                 // don't let sound skip if going slow
9799                 if (r_refdef.scene.extraupdate)
9800                         S_ExtraUpdate ();
9801         }
9802
9803         if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->Draw)
9804         {
9805                 r_refdef.scene.worldmodel->Draw(r_refdef.scene.worldentity);
9806                 if (r_timereport_active)
9807                         R_TimeReport("world");
9808         }
9809
9810         // don't let sound skip if going slow
9811         if (r_refdef.scene.extraupdate)
9812                 S_ExtraUpdate ();
9813
9814         R_DrawModels();
9815         if (r_timereport_active)
9816                 R_TimeReport("models");
9817
9818         // don't let sound skip if going slow
9819         if (r_refdef.scene.extraupdate)
9820                 S_ExtraUpdate ();
9821
9822         if ((r_shadows.integer == 1 || (r_shadows.integer > 0 && !shadowmapping)) && !r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0)
9823         {
9824                 R_DrawModelShadows();
9825                 R_ResetViewRendering3D();
9826                 // don't let sound skip if going slow
9827                 if (r_refdef.scene.extraupdate)
9828                         S_ExtraUpdate ();
9829         }
9830
9831         if (!r_shadow_usingdeferredprepass)
9832         {
9833                 R_Shadow_DrawLights();
9834                 if (r_timereport_active)
9835                         R_TimeReport("rtlights");
9836         }
9837
9838         // don't let sound skip if going slow
9839         if (r_refdef.scene.extraupdate)
9840                 S_ExtraUpdate ();
9841
9842         if ((r_shadows.integer == 1 || (r_shadows.integer > 0 && !shadowmapping)) && r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0)
9843         {
9844                 R_DrawModelShadows();
9845                 R_ResetViewRendering3D();
9846                 // don't let sound skip if going slow
9847                 if (r_refdef.scene.extraupdate)
9848                         S_ExtraUpdate ();
9849         }
9850
9851         if (cl.csqc_vidvars.drawworld)
9852         {
9853                 if (cl_decals_newsystem.integer)
9854                 {
9855                         R_DrawModelDecals();
9856                         if (r_timereport_active)
9857                                 R_TimeReport("modeldecals");
9858                 }
9859                 else
9860                 {
9861                         R_DrawDecals();
9862                         if (r_timereport_active)
9863                                 R_TimeReport("decals");
9864                 }
9865
9866                 R_DrawParticles();
9867                 if (r_timereport_active)
9868                         R_TimeReport("particles");
9869
9870                 R_DrawExplosions();
9871                 if (r_timereport_active)
9872                         R_TimeReport("explosions");
9873
9874                 R_DrawLightningBeams();
9875                 if (r_timereport_active)
9876                         R_TimeReport("lightning");
9877         }
9878
9879         VM_CL_AddPolygonsToMeshQueue();
9880
9881         if (r_refdef.view.showdebug)
9882         {
9883                 if (cl_locs_show.integer)
9884                 {
9885                         R_DrawLocs();
9886                         if (r_timereport_active)
9887                                 R_TimeReport("showlocs");
9888                 }
9889
9890                 if (r_drawportals.integer)
9891                 {
9892                         R_DrawPortals();
9893                         if (r_timereport_active)
9894                                 R_TimeReport("portals");
9895                 }
9896
9897                 if (r_showbboxes.value > 0)
9898                 {
9899                         R_DrawEntityBBoxes();
9900                         if (r_timereport_active)
9901                                 R_TimeReport("bboxes");
9902                 }
9903         }
9904
9905         R_MeshQueue_RenderTransparent();
9906         if (r_timereport_active)
9907                 R_TimeReport("drawtrans");
9908
9909         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))
9910         {
9911                 r_refdef.scene.worldmodel->DrawDebug(r_refdef.scene.worldentity);
9912                 if (r_timereport_active)
9913                         R_TimeReport("worlddebug");
9914                 R_DrawModelsDebug();
9915                 if (r_timereport_active)
9916                         R_TimeReport("modeldebug");
9917         }
9918
9919         if (cl.csqc_vidvars.drawworld)
9920         {
9921                 R_Shadow_DrawCoronas();
9922                 if (r_timereport_active)
9923                         R_TimeReport("coronas");
9924         }
9925
9926 #if 0
9927         {
9928                 GL_DepthTest(false);
9929                 qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
9930                 GL_Color(1, 1, 1, 1);
9931                 qglBegin(GL_POLYGON);
9932                 qglVertex3f(r_refdef.view.frustumcorner[0][0], r_refdef.view.frustumcorner[0][1], r_refdef.view.frustumcorner[0][2]);
9933                 qglVertex3f(r_refdef.view.frustumcorner[1][0], r_refdef.view.frustumcorner[1][1], r_refdef.view.frustumcorner[1][2]);
9934                 qglVertex3f(r_refdef.view.frustumcorner[3][0], r_refdef.view.frustumcorner[3][1], r_refdef.view.frustumcorner[3][2]);
9935                 qglVertex3f(r_refdef.view.frustumcorner[2][0], r_refdef.view.frustumcorner[2][1], r_refdef.view.frustumcorner[2][2]);
9936                 qglEnd();
9937                 qglBegin(GL_POLYGON);
9938                 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]);
9939                 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]);
9940                 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]);
9941                 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]);
9942                 qglEnd();
9943                 qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
9944         }
9945 #endif
9946
9947         // don't let sound skip if going slow
9948         if (r_refdef.scene.extraupdate)
9949                 S_ExtraUpdate ();
9950
9951         R_ResetViewRendering2D();
9952 }
9953
9954 static const unsigned short bboxelements[36] =
9955 {
9956         5, 1, 3, 5, 3, 7,
9957         6, 2, 0, 6, 0, 4,
9958         7, 3, 2, 7, 2, 6,
9959         4, 0, 1, 4, 1, 5,
9960         4, 5, 7, 4, 7, 6,
9961         1, 0, 2, 1, 2, 3,
9962 };
9963
9964 void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
9965 {
9966         int i;
9967         float *v, *c, f1, f2, vertex3f[8*3], color4f[8*4];
9968
9969         RSurf_ActiveWorldEntity();
9970
9971         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
9972         GL_DepthMask(false);
9973         GL_DepthRange(0, 1);
9974         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
9975         R_Mesh_ResetTextureState();
9976
9977         vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2]; //
9978         vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2];
9979         vertex3f[ 6] = mins[0];vertex3f[ 7] = maxs[1];vertex3f[ 8] = mins[2];
9980         vertex3f[ 9] = maxs[0];vertex3f[10] = maxs[1];vertex3f[11] = mins[2];
9981         vertex3f[12] = mins[0];vertex3f[13] = mins[1];vertex3f[14] = maxs[2];
9982         vertex3f[15] = maxs[0];vertex3f[16] = mins[1];vertex3f[17] = maxs[2];
9983         vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
9984         vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
9985         R_FillColors(color4f, 8, cr, cg, cb, ca);
9986         if (r_refdef.fogenabled)
9987         {
9988                 for (i = 0, v = vertex3f, c = color4f;i < 8;i++, v += 3, c += 4)
9989                 {
9990                         f1 = RSurf_FogVertex(v);
9991                         f2 = 1 - f1;
9992                         c[0] = c[0] * f1 + r_refdef.fogcolor[0] * f2;
9993                         c[1] = c[1] * f1 + r_refdef.fogcolor[1] * f2;
9994                         c[2] = c[2] * f1 + r_refdef.fogcolor[2] * f2;
9995                 }
9996         }
9997         R_Mesh_PrepareVertices_Generic_Arrays(8, vertex3f, color4f, NULL);
9998         R_Mesh_ResetTextureState();
9999         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
10000         R_Mesh_Draw(0, 8, 0, 12, NULL, NULL, 0, bboxelements, NULL, 0);
10001 }
10002
10003 static void R_DrawEntityBBoxes_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
10004 {
10005         int i;
10006         float color[4];
10007         prvm_edict_t *edict;
10008         prvm_prog_t *prog_save = prog;
10009
10010         // this function draws bounding boxes of server entities
10011         if (!sv.active)
10012                 return;
10013
10014         GL_CullFace(GL_NONE);
10015         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
10016
10017         prog = 0;
10018         SV_VM_Begin();
10019         for (i = 0;i < numsurfaces;i++)
10020         {
10021                 edict = PRVM_EDICT_NUM(surfacelist[i]);
10022                 switch ((int)edict->fields.server->solid)
10023                 {
10024                         case SOLID_NOT:      Vector4Set(color, 1, 1, 1, 0.05);break;
10025                         case SOLID_TRIGGER:  Vector4Set(color, 1, 0, 1, 0.10);break;
10026                         case SOLID_BBOX:     Vector4Set(color, 0, 1, 0, 0.10);break;
10027                         case SOLID_SLIDEBOX: Vector4Set(color, 1, 0, 0, 0.10);break;
10028                         case SOLID_BSP:      Vector4Set(color, 0, 0, 1, 0.05);break;
10029                         default:             Vector4Set(color, 0, 0, 0, 0.50);break;
10030                 }
10031                 color[3] *= r_showbboxes.value;
10032                 color[3] = bound(0, color[3], 1);
10033                 GL_DepthTest(!r_showdisabledepthtest.integer);
10034                 GL_CullFace(r_refdef.view.cullface_front);
10035                 R_DrawBBoxMesh(edict->priv.server->areamins, edict->priv.server->areamaxs, color[0], color[1], color[2], color[3]);
10036         }
10037         SV_VM_End();
10038         prog = prog_save;
10039 }
10040
10041 static void R_DrawEntityBBoxes(void)
10042 {
10043         int i;
10044         prvm_edict_t *edict;
10045         vec3_t center;
10046         prvm_prog_t *prog_save = prog;
10047
10048         // this function draws bounding boxes of server entities
10049         if (!sv.active)
10050                 return;
10051
10052         prog = 0;
10053         SV_VM_Begin();
10054         for (i = 0;i < prog->num_edicts;i++)
10055         {
10056                 edict = PRVM_EDICT_NUM(i);
10057                 if (edict->priv.server->free)
10058                         continue;
10059                 // exclude the following for now, as they don't live in world coordinate space and can't be solid:
10060                 if(PRVM_EDICTFIELDVALUE(edict, prog->fieldoffsets.tag_entity)->edict != 0)
10061                         continue;
10062                 if(PRVM_EDICTFIELDVALUE(edict, prog->fieldoffsets.viewmodelforclient)->edict != 0)
10063                         continue;
10064                 VectorLerp(edict->priv.server->areamins, 0.5f, edict->priv.server->areamaxs, center);
10065                 R_MeshQueue_AddTransparent(center, R_DrawEntityBBoxes_Callback, (entity_render_t *)NULL, i, (rtlight_t *)NULL);
10066         }
10067         SV_VM_End();
10068         prog = prog_save;
10069 }
10070
10071 static const int nomodelelement3i[24] =
10072 {
10073         5, 2, 0,
10074         5, 1, 2,
10075         5, 0, 3,
10076         5, 3, 1,
10077         0, 2, 4,
10078         2, 1, 4,
10079         3, 0, 4,
10080         1, 3, 4
10081 };
10082
10083 static const unsigned short nomodelelement3s[24] =
10084 {
10085         5, 2, 0,
10086         5, 1, 2,
10087         5, 0, 3,
10088         5, 3, 1,
10089         0, 2, 4,
10090         2, 1, 4,
10091         3, 0, 4,
10092         1, 3, 4
10093 };
10094
10095 static const float nomodelvertex3f[6*3] =
10096 {
10097         -16,   0,   0,
10098          16,   0,   0,
10099           0, -16,   0,
10100           0,  16,   0,
10101           0,   0, -16,
10102           0,   0,  16
10103 };
10104
10105 static const float nomodelcolor4f[6*4] =
10106 {
10107         0.0f, 0.0f, 0.5f, 1.0f,
10108         0.0f, 0.0f, 0.5f, 1.0f,
10109         0.0f, 0.5f, 0.0f, 1.0f,
10110         0.0f, 0.5f, 0.0f, 1.0f,
10111         0.5f, 0.0f, 0.0f, 1.0f,
10112         0.5f, 0.0f, 0.0f, 1.0f
10113 };
10114
10115 void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
10116 {
10117         int i;
10118         float f1, f2, *c;
10119         float color4f[6*4];
10120
10121         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);
10122
10123         // this is only called once per entity so numsurfaces is always 1, and
10124         // surfacelist is always {0}, so this code does not handle batches
10125
10126         if (rsurface.ent_flags & RENDER_ADDITIVE)
10127         {
10128                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
10129                 GL_DepthMask(false);
10130         }
10131         else if (rsurface.colormod[3] < 1)
10132         {
10133                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
10134                 GL_DepthMask(false);
10135         }
10136         else
10137         {
10138                 GL_BlendFunc(GL_ONE, GL_ZERO);
10139                 GL_DepthMask(true);
10140         }
10141         GL_DepthRange(0, (rsurface.ent_flags & RENDER_VIEWMODEL) ? 0.0625 : 1);
10142         GL_PolygonOffset(rsurface.basepolygonfactor, rsurface.basepolygonoffset);
10143         GL_DepthTest(!(rsurface.ent_flags & RENDER_NODEPTHTEST));
10144         GL_CullFace((rsurface.ent_flags & RENDER_DOUBLESIDED) ? GL_NONE : r_refdef.view.cullface_back);
10145         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
10146         memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
10147         for (i = 0, c = color4f;i < 6;i++, c += 4)
10148         {
10149                 c[0] *= rsurface.colormod[0];
10150                 c[1] *= rsurface.colormod[1];
10151                 c[2] *= rsurface.colormod[2];
10152                 c[3] *= rsurface.colormod[3];
10153         }
10154         if (r_refdef.fogenabled)
10155         {
10156                 for (i = 0, c = color4f;i < 6;i++, c += 4)
10157                 {
10158                         f1 = RSurf_FogVertex(nomodelvertex3f + 3*i);
10159                         f2 = 1 - f1;
10160                         c[0] = (c[0] * f1 + r_refdef.fogcolor[0] * f2);
10161                         c[1] = (c[1] * f1 + r_refdef.fogcolor[1] * f2);
10162                         c[2] = (c[2] * f1 + r_refdef.fogcolor[2] * f2);
10163                 }
10164         }
10165         R_Mesh_ResetTextureState();
10166         R_Mesh_PrepareVertices_Generic_Arrays(6, nomodelvertex3f, color4f, NULL);
10167         R_Mesh_Draw(0, 6, 0, 8, nomodelelement3i, NULL, 0, nomodelelement3s, NULL, 0);
10168 }
10169
10170 void R_DrawNoModel(entity_render_t *ent)
10171 {
10172         vec3_t org;
10173         Matrix4x4_OriginFromMatrix(&ent->matrix, org);
10174         if ((ent->flags & RENDER_ADDITIVE) || (ent->alpha < 1))
10175                 R_MeshQueue_AddTransparent(ent->flags & RENDER_NODEPTHTEST ? r_refdef.view.origin : org, R_DrawNoModel_TransparentCallback, ent, 0, rsurface.rtlight);
10176         else
10177                 R_DrawNoModel_TransparentCallback(ent, rsurface.rtlight, 0, NULL);
10178 }
10179
10180 void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
10181 {
10182         vec3_t right1, right2, diff, normal;
10183
10184         VectorSubtract (org2, org1, normal);
10185
10186         // calculate 'right' vector for start
10187         VectorSubtract (r_refdef.view.origin, org1, diff);
10188         CrossProduct (normal, diff, right1);
10189         VectorNormalize (right1);
10190
10191         // calculate 'right' vector for end
10192         VectorSubtract (r_refdef.view.origin, org2, diff);
10193         CrossProduct (normal, diff, right2);
10194         VectorNormalize (right2);
10195
10196         vert[ 0] = org1[0] + width * right1[0];
10197         vert[ 1] = org1[1] + width * right1[1];
10198         vert[ 2] = org1[2] + width * right1[2];
10199         vert[ 3] = org1[0] - width * right1[0];
10200         vert[ 4] = org1[1] - width * right1[1];
10201         vert[ 5] = org1[2] - width * right1[2];
10202         vert[ 6] = org2[0] - width * right2[0];
10203         vert[ 7] = org2[1] - width * right2[1];
10204         vert[ 8] = org2[2] - width * right2[2];
10205         vert[ 9] = org2[0] + width * right2[0];
10206         vert[10] = org2[1] + width * right2[1];
10207         vert[11] = org2[2] + width * right2[2];
10208 }
10209
10210 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)
10211 {
10212         vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
10213         vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
10214         vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
10215         vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
10216         vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
10217         vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
10218         vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
10219         vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
10220         vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
10221         vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
10222         vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
10223         vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
10224 }
10225
10226 int R_Mesh_AddVertex(rmesh_t *mesh, float x, float y, float z)
10227 {
10228         int i;
10229         float *vertex3f;
10230         float v[3];
10231         VectorSet(v, x, y, z);
10232         for (i = 0, vertex3f = mesh->vertex3f;i < mesh->numvertices;i++, vertex3f += 3)
10233                 if (VectorDistance2(v, vertex3f) < mesh->epsilon2)
10234                         break;
10235         if (i == mesh->numvertices)
10236         {
10237                 if (mesh->numvertices < mesh->maxvertices)
10238                 {
10239                         VectorCopy(v, vertex3f);
10240                         mesh->numvertices++;
10241                 }
10242                 return mesh->numvertices;
10243         }
10244         else
10245                 return i;
10246 }
10247
10248 void R_Mesh_AddPolygon3f(rmesh_t *mesh, int numvertices, float *vertex3f)
10249 {
10250         int i;
10251         int *e, element[3];
10252         element[0] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
10253         element[1] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
10254         e = mesh->element3i + mesh->numtriangles * 3;
10255         for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
10256         {
10257                 element[2] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);
10258                 if (mesh->numtriangles < mesh->maxtriangles)
10259                 {
10260                         *e++ = element[0];
10261                         *e++ = element[1];
10262                         *e++ = element[2];
10263                         mesh->numtriangles++;
10264                 }
10265                 element[1] = element[2];
10266         }
10267 }
10268
10269 void R_Mesh_AddPolygon3d(rmesh_t *mesh, int numvertices, double *vertex3d)
10270 {
10271         int i;
10272         int *e, element[3];
10273         element[0] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
10274         element[1] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
10275         e = mesh->element3i + mesh->numtriangles * 3;
10276         for (i = 0;i < numvertices - 2;i++, vertex3d += 3)
10277         {
10278                 element[2] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);
10279                 if (mesh->numtriangles < mesh->maxtriangles)
10280                 {
10281                         *e++ = element[0];
10282                         *e++ = element[1];
10283                         *e++ = element[2];
10284                         mesh->numtriangles++;
10285                 }
10286                 element[1] = element[2];
10287         }
10288 }
10289
10290 #define R_MESH_PLANE_DIST_EPSILON (1.0 / 32.0)
10291 void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes)
10292 {
10293         int planenum, planenum2;
10294         int w;
10295         int tempnumpoints;
10296         mplane_t *plane, *plane2;
10297         double maxdist;
10298         double temppoints[2][256*3];
10299         // figure out how large a bounding box we need to properly compute this brush
10300         maxdist = 0;
10301         for (w = 0;w < numplanes;w++)
10302                 maxdist = max(maxdist, fabs(planes[w].dist));
10303         // now make it large enough to enclose the entire brush, and round it off to a reasonable multiple of 1024
10304         maxdist = floor(maxdist * (4.0 / 1024.0) + 1) * 1024.0;
10305         for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
10306         {
10307                 w = 0;
10308                 tempnumpoints = 4;
10309                 PolygonD_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, maxdist);
10310                 for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
10311                 {
10312                         if (planenum2 == planenum)
10313                                 continue;
10314                         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);
10315                         w = !w;
10316                 }
10317                 if (tempnumpoints < 3)
10318                         continue;
10319                 // generate elements forming a triangle fan for this polygon
10320                 R_Mesh_AddPolygon3d(mesh, tempnumpoints, temppoints[w]);
10321         }
10322 }
10323
10324 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)
10325 {
10326         texturelayer_t *layer;
10327         layer = t->currentlayers + t->currentnumlayers++;
10328         layer->type = type;
10329         layer->depthmask = depthmask;
10330         layer->blendfunc1 = blendfunc1;
10331         layer->blendfunc2 = blendfunc2;
10332         layer->texture = texture;
10333         layer->texmatrix = *matrix;
10334         layer->color[0] = r;
10335         layer->color[1] = g;
10336         layer->color[2] = b;
10337         layer->color[3] = a;
10338 }
10339
10340 static qboolean R_TestQ3WaveFunc(q3wavefunc_t func, const float *parms)
10341 {
10342         if(parms[0] == 0 && parms[1] == 0)
10343                 return false;
10344         if(func >> Q3WAVEFUNC_USER_SHIFT) // assumes rsurface to be set!
10345                 if(rsurface.userwavefunc_param[bound(0, (func >> Q3WAVEFUNC_USER_SHIFT) - 1, Q3WAVEFUNC_USER_COUNT)] == 0)
10346                         return false;
10347         return true;
10348 }
10349
10350 static float R_EvaluateQ3WaveFunc(q3wavefunc_t func, const float *parms)
10351 {
10352         double index, f;
10353         index = parms[2] + r_refdef.scene.time * parms[3];
10354         index -= floor(index);
10355         switch (func & ((1 << Q3WAVEFUNC_USER_SHIFT) - 1))
10356         {
10357         default:
10358         case Q3WAVEFUNC_NONE:
10359         case Q3WAVEFUNC_NOISE:
10360         case Q3WAVEFUNC_COUNT:
10361                 f = 0;
10362                 break;
10363         case Q3WAVEFUNC_SIN: f = sin(index * M_PI * 2);break;
10364         case Q3WAVEFUNC_SQUARE: f = index < 0.5 ? 1 : -1;break;
10365         case Q3WAVEFUNC_SAWTOOTH: f = index;break;
10366         case Q3WAVEFUNC_INVERSESAWTOOTH: f = 1 - index;break;
10367         case Q3WAVEFUNC_TRIANGLE:
10368                 index *= 4;
10369                 f = index - floor(index);
10370                 if (index < 1)
10371                         f = f;
10372                 else if (index < 2)
10373                         f = 1 - f;
10374                 else if (index < 3)
10375                         f = -f;
10376                 else
10377                         f = -(1 - f);
10378                 break;
10379         }
10380         f = parms[0] + parms[1] * f;
10381         if(func >> Q3WAVEFUNC_USER_SHIFT) // assumes rsurface to be set!
10382                 f *= rsurface.userwavefunc_param[bound(0, (func >> Q3WAVEFUNC_USER_SHIFT) - 1, Q3WAVEFUNC_USER_COUNT)];
10383         return (float) f;
10384 }
10385
10386 void R_tcMod_ApplyToMatrix(matrix4x4_t *texmatrix, q3shaderinfo_layer_tcmod_t *tcmod, int currentmaterialflags)
10387 {
10388         int w, h, idx;
10389         float f;
10390         float tcmat[12];
10391         matrix4x4_t matrix, temp;
10392         switch(tcmod->tcmod)
10393         {
10394                 case Q3TCMOD_COUNT:
10395                 case Q3TCMOD_NONE:
10396                         if (currentmaterialflags & MATERIALFLAG_WATERSCROLL)
10397                                 matrix = r_waterscrollmatrix;
10398                         else
10399                                 matrix = identitymatrix;
10400                         break;
10401                 case Q3TCMOD_ENTITYTRANSLATE:
10402                         // this is used in Q3 to allow the gamecode to control texcoord
10403                         // scrolling on the entity, which is not supported in darkplaces yet.
10404                         Matrix4x4_CreateTranslate(&matrix, 0, 0, 0);
10405                         break;
10406                 case Q3TCMOD_ROTATE:
10407                         Matrix4x4_CreateTranslate(&matrix, 0.5, 0.5, 0);
10408                         Matrix4x4_ConcatRotate(&matrix, tcmod->parms[0] * r_refdef.scene.time, 0, 0, 1);
10409                         Matrix4x4_ConcatTranslate(&matrix, -0.5, -0.5, 0);
10410                         break;
10411                 case Q3TCMOD_SCALE:
10412                         Matrix4x4_CreateScale3(&matrix, tcmod->parms[0], tcmod->parms[1], 1);
10413                         break;
10414                 case Q3TCMOD_SCROLL:
10415                         Matrix4x4_CreateTranslate(&matrix, tcmod->parms[0] * r_refdef.scene.time, tcmod->parms[1] * r_refdef.scene.time, 0);
10416                         break;
10417                 case Q3TCMOD_PAGE: // poor man's animmap (to store animations into a single file, useful for HTTP downloaded textures)
10418                         w = (int) tcmod->parms[0];
10419                         h = (int) tcmod->parms[1];
10420                         f = r_refdef.scene.time / (tcmod->parms[2] * w * h);
10421                         f = f - floor(f);
10422                         idx = (int) floor(f * w * h);
10423                         Matrix4x4_CreateTranslate(&matrix, (idx % w) / tcmod->parms[0], (idx / w) / tcmod->parms[1], 0);
10424                         break;
10425                 case Q3TCMOD_STRETCH:
10426                         f = 1.0f / R_EvaluateQ3WaveFunc(tcmod->wavefunc, tcmod->waveparms);
10427                         Matrix4x4_CreateFromQuakeEntity(&matrix, 0.5f * (1 - f), 0.5 * (1 - f), 0, 0, 0, 0, f);
10428                         break;
10429                 case Q3TCMOD_TRANSFORM:
10430                         VectorSet(tcmat +  0, tcmod->parms[0], tcmod->parms[1], 0);
10431                         VectorSet(tcmat +  3, tcmod->parms[2], tcmod->parms[3], 0);
10432                         VectorSet(tcmat +  6, 0                   , 0                , 1);
10433                         VectorSet(tcmat +  9, tcmod->parms[4], tcmod->parms[5], 0);
10434                         Matrix4x4_FromArray12FloatGL(&matrix, tcmat);
10435                         break;
10436                 case Q3TCMOD_TURBULENT:
10437                         // this is handled in the RSurf_PrepareVertices function
10438                         matrix = identitymatrix;
10439                         break;
10440         }
10441         temp = *texmatrix;
10442         Matrix4x4_Concat(texmatrix, &matrix, &temp);
10443 }
10444
10445 void R_LoadQWSkin(r_qwskincache_t *cache, const char *skinname)
10446 {
10447         int textureflags = (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_PICMIP | TEXF_COMPRESS;
10448         char name[MAX_QPATH];
10449         skinframe_t *skinframe;
10450         unsigned char pixels[296*194];
10451         strlcpy(cache->name, skinname, sizeof(cache->name));
10452         dpsnprintf(name, sizeof(name), "skins/%s.pcx", cache->name);
10453         if (developer_loading.integer)
10454                 Con_Printf("loading %s\n", name);
10455         skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
10456         if (!skinframe || !skinframe->base)
10457         {
10458                 unsigned char *f;
10459                 fs_offset_t filesize;
10460                 skinframe = NULL;
10461                 f = FS_LoadFile(name, tempmempool, true, &filesize);
10462                 if (f)
10463                 {
10464                         if (LoadPCX_QWSkin(f, (int)filesize, pixels, 296, 194))
10465                                 skinframe = R_SkinFrame_LoadInternalQuake(name, textureflags, true, r_fullbrights.integer, pixels, image_width, image_height);
10466                         Mem_Free(f);
10467                 }
10468         }
10469         cache->skinframe = skinframe;
10470 }
10471
10472 texture_t *R_GetCurrentTexture(texture_t *t)
10473 {
10474         int i;
10475         const entity_render_t *ent = rsurface.entity;
10476         dp_model_t *model = ent->model;
10477         q3shaderinfo_layer_tcmod_t *tcmod;
10478
10479         if (t->update_lastrenderframe == r_textureframe && t->update_lastrenderentity == (void *)ent)
10480                 return t->currentframe;
10481         t->update_lastrenderframe = r_textureframe;
10482         t->update_lastrenderentity = (void *)ent;
10483
10484         if(ent && ent->entitynumber >= MAX_EDICTS && ent->entitynumber < 2 * MAX_EDICTS)
10485                 t->camera_entity = ent->entitynumber;
10486         else
10487                 t->camera_entity = 0;
10488
10489         // switch to an alternate material if this is a q1bsp animated material
10490         {
10491                 texture_t *texture = t;
10492                 int s = rsurface.ent_skinnum;
10493                 if ((unsigned int)s >= (unsigned int)model->numskins)
10494                         s = 0;
10495                 if (model->skinscenes)
10496                 {
10497                         if (model->skinscenes[s].framecount > 1)
10498                                 s = model->skinscenes[s].firstframe + (unsigned int) (r_refdef.scene.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
10499                         else
10500                                 s = model->skinscenes[s].firstframe;
10501                 }
10502                 if (s > 0)
10503                         t = t + s * model->num_surfaces;
10504                 if (t->animated)
10505                 {
10506                         // use an alternate animation if the entity's frame is not 0,
10507                         // and only if the texture has an alternate animation
10508                         if (rsurface.ent_alttextures && t->anim_total[1])
10509                                 t = t->anim_frames[1][(t->anim_total[1] >= 2) ? ((int)(r_refdef.scene.time * 5.0f) % t->anim_total[1]) : 0];
10510                         else
10511                                 t = t->anim_frames[0][(t->anim_total[0] >= 2) ? ((int)(r_refdef.scene.time * 5.0f) % t->anim_total[0]) : 0];
10512                 }
10513                 texture->currentframe = t;
10514         }
10515
10516         // update currentskinframe to be a qw skin or animation frame
10517         if (rsurface.ent_qwskin >= 0)
10518         {
10519                 i = rsurface.ent_qwskin;
10520                 if (!r_qwskincache || r_qwskincache_size != cl.maxclients)
10521                 {
10522                         r_qwskincache_size = cl.maxclients;
10523                         if (r_qwskincache)
10524                                 Mem_Free(r_qwskincache);
10525                         r_qwskincache = (r_qwskincache_t *)Mem_Alloc(r_main_mempool, sizeof(*r_qwskincache) * r_qwskincache_size);
10526                 }
10527                 if (strcmp(r_qwskincache[i].name, cl.scores[i].qw_skin))
10528                         R_LoadQWSkin(&r_qwskincache[i], cl.scores[i].qw_skin);
10529                 t->currentskinframe = r_qwskincache[i].skinframe;
10530                 if (t->currentskinframe == NULL)
10531                         t->currentskinframe = t->skinframes[(unsigned int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes];
10532         }
10533         else if (t->numskinframes >= 2)
10534                 t->currentskinframe = t->skinframes[(unsigned int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes];
10535         if (t->backgroundnumskinframes >= 2)
10536                 t->backgroundcurrentskinframe = t->backgroundskinframes[(unsigned int)(t->backgroundskinframerate * (cl.time - rsurface.ent_shadertime)) % t->backgroundnumskinframes];
10537
10538         t->currentmaterialflags = t->basematerialflags;
10539         t->currentalpha = rsurface.colormod[3];
10540         if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_novis.integer))
10541                 t->currentalpha *= r_wateralpha.value;
10542         if(t->basematerialflags & MATERIALFLAG_WATERSHADER && r_waterstate.enabled && !r_refdef.view.isoverlay)
10543                 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW; // we apply wateralpha later
10544         if(!r_waterstate.enabled || r_refdef.view.isoverlay)
10545                 t->currentmaterialflags &= ~(MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA);
10546         if (!(rsurface.ent_flags & RENDER_LIGHT))
10547                 t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
10548         else if (FAKELIGHT_ENABLED)
10549         {
10550                         // no modellight if using fakelight for the map
10551         }
10552         else if (rsurface.modeltexcoordlightmap2f == NULL && !(t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
10553         {
10554                 // pick a model lighting mode
10555                 if (VectorLength2(rsurface.modellight_diffuse) >= (1.0f / 256.0f))
10556                         t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL;
10557                 else
10558                         t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT;
10559         }
10560         if (rsurface.ent_flags & RENDER_ADDITIVE)
10561                 t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
10562         else if (t->currentalpha < 1)
10563                 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
10564         if (rsurface.ent_flags & RENDER_DOUBLESIDED)
10565                 t->currentmaterialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_NOCULLFACE;
10566         if (rsurface.ent_flags & (RENDER_NODEPTHTEST | RENDER_VIEWMODEL))
10567                 t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
10568         if (t->backgroundnumskinframes)
10569                 t->currentmaterialflags |= MATERIALFLAG_VERTEXTEXTUREBLEND;
10570         if (t->currentmaterialflags & MATERIALFLAG_BLENDED)
10571         {
10572                 if (t->currentmaterialflags & (MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER | MATERIALFLAG_CAMERA))
10573                         t->currentmaterialflags &= ~MATERIALFLAG_BLENDED;
10574         }
10575         else
10576                 t->currentmaterialflags &= ~(MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER | MATERIALFLAG_CAMERA);
10577         if ((t->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST)) == MATERIALFLAG_BLENDED && r_transparentdepthmasking.integer && !(t->basematerialflags & MATERIALFLAG_BLENDED))
10578                 t->currentmaterialflags |= MATERIALFLAG_TRANSDEPTH;
10579
10580         // there is no tcmod
10581         if (t->currentmaterialflags & MATERIALFLAG_WATERSCROLL)
10582         {
10583                 t->currenttexmatrix = r_waterscrollmatrix;
10584                 t->currentbackgroundtexmatrix = r_waterscrollmatrix;
10585         }
10586         else if (!(t->currentmaterialflags & MATERIALFLAG_CUSTOMSURFACE))
10587         {
10588                 Matrix4x4_CreateIdentity(&t->currenttexmatrix);
10589                 Matrix4x4_CreateIdentity(&t->currentbackgroundtexmatrix);
10590         }
10591
10592         for (i = 0, tcmod = t->tcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
10593                 R_tcMod_ApplyToMatrix(&t->currenttexmatrix, tcmod, t->currentmaterialflags);
10594         for (i = 0, tcmod = t->backgroundtcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
10595                 R_tcMod_ApplyToMatrix(&t->currentbackgroundtexmatrix, tcmod, t->currentmaterialflags);
10596
10597         t->colormapping = VectorLength2(rsurface.colormap_pantscolor) + VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f);
10598         if (t->currentskinframe->qpixels)
10599                 R_SkinFrame_GenerateTexturesFromQPixels(t->currentskinframe, t->colormapping);
10600         t->basetexture = (!t->colormapping && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
10601         if (!t->basetexture)
10602                 t->basetexture = r_texture_notexture;
10603         t->pantstexture = t->colormapping ? t->currentskinframe->pants : NULL;
10604         t->shirttexture = t->colormapping ? t->currentskinframe->shirt : NULL;
10605         t->nmaptexture = t->currentskinframe->nmap;
10606         if (!t->nmaptexture)
10607                 t->nmaptexture = r_texture_blanknormalmap;
10608         t->glosstexture = r_texture_black;
10609         t->glowtexture = t->currentskinframe->glow;
10610         t->fogtexture = t->currentskinframe->fog;
10611         t->reflectmasktexture = t->currentskinframe->reflect;
10612         if (t->backgroundnumskinframes)
10613         {
10614                 t->backgroundbasetexture = (!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base;
10615                 t->backgroundnmaptexture = t->backgroundcurrentskinframe->nmap;
10616                 t->backgroundglosstexture = r_texture_black;
10617                 t->backgroundglowtexture = t->backgroundcurrentskinframe->glow;
10618                 if (!t->backgroundnmaptexture)
10619                         t->backgroundnmaptexture = r_texture_blanknormalmap;
10620         }
10621         else
10622         {
10623                 t->backgroundbasetexture = r_texture_white;
10624                 t->backgroundnmaptexture = r_texture_blanknormalmap;
10625                 t->backgroundglosstexture = r_texture_black;
10626                 t->backgroundglowtexture = NULL;
10627         }
10628         t->specularpower = r_shadow_glossexponent.value;
10629         // TODO: store reference values for these in the texture?
10630         t->specularscale = 0;
10631         if (r_shadow_gloss.integer > 0)
10632         {
10633                 if (t->currentskinframe->gloss || (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss))
10634                 {
10635                         if (r_shadow_glossintensity.value > 0)
10636                         {
10637                                 t->glosstexture = t->currentskinframe->gloss ? t->currentskinframe->gloss : r_texture_white;
10638                                 t->backgroundglosstexture = (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss) ? t->backgroundcurrentskinframe->gloss : r_texture_white;
10639                                 t->specularscale = r_shadow_glossintensity.value;
10640                         }
10641                 }
10642                 else if (r_shadow_gloss.integer >= 2 && r_shadow_gloss2intensity.value > 0)
10643                 {
10644                         t->glosstexture = r_texture_white;
10645                         t->backgroundglosstexture = r_texture_white;
10646                         t->specularscale = r_shadow_gloss2intensity.value;
10647                         t->specularpower = r_shadow_gloss2exponent.value;
10648                 }
10649         }
10650         t->specularscale *= t->specularscalemod;
10651         t->specularpower *= t->specularpowermod;
10652
10653         // lightmaps mode looks bad with dlights using actual texturing, so turn
10654         // off the colormap and glossmap, but leave the normalmap on as it still
10655         // accurately represents the shading involved
10656         if (gl_lightmaps.integer)
10657         {
10658                 t->basetexture = r_texture_grey128;
10659                 t->pantstexture = r_texture_black;
10660                 t->shirttexture = r_texture_black;
10661                 t->nmaptexture = r_texture_blanknormalmap;
10662                 t->glosstexture = r_texture_black;
10663                 t->glowtexture = NULL;
10664                 t->fogtexture = NULL;
10665                 t->reflectmasktexture = NULL;
10666                 t->backgroundbasetexture = NULL;
10667                 t->backgroundnmaptexture = r_texture_blanknormalmap;
10668                 t->backgroundglosstexture = r_texture_black;
10669                 t->backgroundglowtexture = NULL;
10670                 t->specularscale = 0;
10671                 t->currentmaterialflags = MATERIALFLAG_WALL | (t->currentmaterialflags & (MATERIALFLAG_NOCULLFACE | MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SHORTDEPTHRANGE));
10672         }
10673
10674         Vector4Set(t->lightmapcolor, rsurface.colormod[0], rsurface.colormod[1], rsurface.colormod[2], t->currentalpha);
10675         VectorClear(t->dlightcolor);
10676         t->currentnumlayers = 0;
10677         if (t->currentmaterialflags & MATERIALFLAG_WALL)
10678         {
10679                 int blendfunc1, blendfunc2;
10680                 qboolean depthmask;
10681                 if (t->currentmaterialflags & MATERIALFLAG_ADD)
10682                 {
10683                         blendfunc1 = GL_SRC_ALPHA;
10684                         blendfunc2 = GL_ONE;
10685                 }
10686                 else if (t->currentmaterialflags & MATERIALFLAG_ALPHA)
10687                 {
10688                         blendfunc1 = GL_SRC_ALPHA;
10689                         blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
10690                 }
10691                 else if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
10692                 {
10693                         blendfunc1 = t->customblendfunc[0];
10694                         blendfunc2 = t->customblendfunc[1];
10695                 }
10696                 else
10697                 {
10698                         blendfunc1 = GL_ONE;
10699                         blendfunc2 = GL_ZERO;
10700                 }
10701                 // don't colormod evilblend textures
10702                 if(!R_BlendFuncAllowsColormod(blendfunc1, blendfunc2))
10703                         VectorSet(t->lightmapcolor, 1, 1, 1);
10704                 depthmask = !(t->currentmaterialflags & MATERIALFLAG_BLENDED);
10705                 if (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
10706                 {
10707                         // fullbright is not affected by r_refdef.lightmapintensity
10708                         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]);
10709                         if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
10710                                 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]);
10711                         if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
10712                                 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]);
10713                 }
10714                 else
10715                 {
10716                         vec3_t ambientcolor;
10717                         float colorscale;
10718                         // set the color tint used for lights affecting this surface
10719                         VectorSet(t->dlightcolor, t->lightmapcolor[0] * t->lightmapcolor[3], t->lightmapcolor[1] * t->lightmapcolor[3], t->lightmapcolor[2] * t->lightmapcolor[3]);
10720                         colorscale = 2;
10721                         // q3bsp has no lightmap updates, so the lightstylevalue that
10722                         // would normally be baked into the lightmap must be
10723                         // applied to the color
10724                         // FIXME: r_glsl 1 rendering doesn't support overbright lightstyles with this (the default light style is not overbright)
10725                         if (model->type == mod_brushq3)
10726                                 colorscale *= r_refdef.scene.rtlightstylevalue[0];
10727                         colorscale *= r_refdef.lightmapintensity;
10728                         VectorScale(t->lightmapcolor, r_refdef.scene.ambient, ambientcolor);
10729                         VectorScale(t->lightmapcolor, colorscale, t->lightmapcolor);
10730                         // basic lit geometry
10731                         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]);
10732                         // add pants/shirt if needed
10733                         if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
10734                                 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]);
10735                         if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
10736                                 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]);
10737                         // now add ambient passes if needed
10738                         if (VectorLength2(ambientcolor) >= (1.0f/1048576.0f))
10739                         {
10740                                 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]);
10741                                 if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
10742                                         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]);
10743                                 if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
10744                                         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]);
10745                         }
10746                 }
10747                 if (t->glowtexture != NULL && !gl_lightmaps.integer)
10748                         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]);
10749                 if (r_refdef.fogenabled && !(t->currentmaterialflags & MATERIALFLAG_ADD))
10750                 {
10751                         // if this is opaque use alpha blend which will darken the earlier
10752                         // passes cheaply.
10753                         //
10754                         // if this is an alpha blended material, all the earlier passes
10755                         // were darkened by fog already, so we only need to add the fog
10756                         // color ontop through the fog mask texture
10757                         //
10758                         // if this is an additive blended material, all the earlier passes
10759                         // were darkened by fog already, and we should not add fog color
10760                         // (because the background was not darkened, there is no fog color
10761                         // that was lost behind it).
10762                         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]);
10763                 }
10764         }
10765
10766         return t->currentframe;
10767 }
10768
10769 rsurfacestate_t rsurface;
10770
10771 void R_Mesh_ResizeArrays(int newvertices)
10772 {
10773         unsigned char *base;
10774         size_t size;
10775         if (rsurface.array_size >= newvertices)
10776                 return;
10777         if (rsurface.array_base)
10778                 Mem_Free(rsurface.array_base);
10779         rsurface.array_size = (newvertices + 1023) & ~1023;
10780         size = 0;
10781         size += rsurface.array_size * sizeof(*rsurface.array_modelvertexmesh);
10782         size += rsurface.array_size * sizeof(*rsurface.array_batchvertexmesh);
10783         size += rsurface.array_size * sizeof(*rsurface.array_modelvertexposition);
10784         size += rsurface.array_size * sizeof(*rsurface.array_batchvertexposition);
10785         size += rsurface.array_size * sizeof(float[3]);
10786         size += rsurface.array_size * sizeof(float[3]);
10787         size += rsurface.array_size * sizeof(float[3]);
10788         size += rsurface.array_size * sizeof(float[3]);
10789         size += rsurface.array_size * sizeof(float[3]);
10790         size += rsurface.array_size * sizeof(float[3]);
10791         size += rsurface.array_size * sizeof(float[3]);
10792         size += rsurface.array_size * sizeof(float[3]);
10793         size += rsurface.array_size * sizeof(float[4]);
10794         size += rsurface.array_size * sizeof(float[2]);
10795         size += rsurface.array_size * sizeof(float[2]);
10796         size += rsurface.array_size * sizeof(float[4]);
10797         size += rsurface.array_size * sizeof(int[3]);
10798         size += rsurface.array_size * sizeof(unsigned short[3]);
10799         rsurface.array_base = base = (unsigned char *)Mem_Alloc(r_main_mempool, size);
10800         rsurface.array_modelvertexmesh         = (r_vertexmesh_t     *)base;base += rsurface.array_size * sizeof(*rsurface.array_modelvertexmesh);
10801         rsurface.array_batchvertexmesh         = (r_vertexmesh_t     *)base;base += rsurface.array_size * sizeof(*rsurface.array_batchvertexmesh);
10802         rsurface.array_modelvertexposition     = (r_vertexposition_t *)base;base += rsurface.array_size * sizeof(*rsurface.array_modelvertexposition);
10803         rsurface.array_batchvertexposition     = (r_vertexposition_t *)base;base += rsurface.array_size * sizeof(*rsurface.array_batchvertexposition);
10804         rsurface.array_modelvertex3f           = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10805         rsurface.array_modelsvector3f          = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10806         rsurface.array_modeltvector3f          = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10807         rsurface.array_modelnormal3f           = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10808         rsurface.array_batchvertex3f           = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10809         rsurface.array_batchsvector3f          = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10810         rsurface.array_batchtvector3f          = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10811         rsurface.array_batchnormal3f           = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10812         rsurface.array_batchlightmapcolor4f    = (float              *)base;base += rsurface.array_size * sizeof(float[4]);
10813         rsurface.array_batchtexcoordtexture2f  = (float              *)base;base += rsurface.array_size * sizeof(float[2]);
10814         rsurface.array_batchtexcoordlightmap2f = (float              *)base;base += rsurface.array_size * sizeof(float[2]);
10815         rsurface.array_passcolor4f             = (float              *)base;base += rsurface.array_size * sizeof(float[4]);
10816         rsurface.array_batchelement3i          = (int                *)base;base += rsurface.array_size * sizeof(int[3]);
10817         rsurface.array_batchelement3s          = (unsigned short     *)base;base += rsurface.array_size * sizeof(unsigned short[3]);
10818 }
10819
10820 void RSurf_ActiveWorldEntity(void)
10821 {
10822         dp_model_t *model = r_refdef.scene.worldmodel;
10823         //if (rsurface.entity == r_refdef.scene.worldentity)
10824         //      return;
10825         rsurface.entity = r_refdef.scene.worldentity;
10826         rsurface.skeleton = NULL;
10827         memset(rsurface.userwavefunc_param, 0, sizeof(rsurface.userwavefunc_param));
10828         rsurface.ent_skinnum = 0;
10829         rsurface.ent_qwskin = -1;
10830         rsurface.ent_shadertime = 0;
10831         rsurface.ent_flags = r_refdef.scene.worldentity->flags;
10832         R_Mesh_ResizeArrays(max(model->surfmesh.num_vertices, model->surfmesh.num_triangles));
10833         rsurface.matrix = identitymatrix;
10834         rsurface.inversematrix = identitymatrix;
10835         rsurface.matrixscale = 1;
10836         rsurface.inversematrixscale = 1;
10837         R_EntityMatrix(&identitymatrix);
10838         VectorCopy(r_refdef.view.origin, rsurface.localvieworigin);
10839         Vector4Copy(r_refdef.fogplane, rsurface.fogplane);
10840         rsurface.fograngerecip = r_refdef.fograngerecip;
10841         rsurface.fogheightfade = r_refdef.fogheightfade;
10842         rsurface.fogplaneviewdist = r_refdef.fogplaneviewdist;
10843         rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
10844         VectorSet(rsurface.modellight_ambient, 0, 0, 0);
10845         VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
10846         VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
10847         VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
10848         VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
10849         VectorSet(rsurface.colormod, r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale);
10850         rsurface.colormod[3] = 1;
10851         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);
10852         memset(rsurface.frameblend, 0, sizeof(rsurface.frameblend));
10853         rsurface.frameblend[0].lerp = 1;
10854         rsurface.ent_alttextures = false;
10855         rsurface.basepolygonfactor = r_refdef.polygonfactor;
10856         rsurface.basepolygonoffset = r_refdef.polygonoffset;
10857         rsurface.modelvertex3f  = model->surfmesh.data_vertex3f;
10858         rsurface.modelvertex3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
10859         rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
10860         rsurface.modelsvector3f = model->surfmesh.data_svector3f;
10861         rsurface.modelsvector3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
10862         rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
10863         rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
10864         rsurface.modeltvector3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
10865         rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
10866         rsurface.modelnormal3f  = model->surfmesh.data_normal3f;
10867         rsurface.modelnormal3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
10868         rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
10869         rsurface.modellightmapcolor4f  = model->surfmesh.data_lightmapcolor4f;
10870         rsurface.modellightmapcolor4f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
10871         rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
10872         rsurface.modeltexcoordtexture2f  = model->surfmesh.data_texcoordtexture2f;
10873         rsurface.modeltexcoordtexture2f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
10874         rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
10875         rsurface.modeltexcoordlightmap2f  = model->surfmesh.data_texcoordlightmap2f;
10876         rsurface.modeltexcoordlightmap2f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
10877         rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
10878         rsurface.modelelement3i = model->surfmesh.data_element3i;
10879         rsurface.modelelement3i_indexbuffer = model->surfmesh.data_element3i_indexbuffer;
10880         rsurface.modelelement3i_bufferoffset = model->surfmesh.data_element3i_bufferoffset;
10881         rsurface.modelelement3s = model->surfmesh.data_element3s;
10882         rsurface.modelelement3s_indexbuffer = model->surfmesh.data_element3s_indexbuffer;
10883         rsurface.modelelement3s_bufferoffset = model->surfmesh.data_element3s_bufferoffset;
10884         rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
10885         rsurface.modelnumvertices = model->surfmesh.num_vertices;
10886         rsurface.modelnumtriangles = model->surfmesh.num_triangles;
10887         rsurface.modelsurfaces = model->data_surfaces;
10888         rsurface.modelvertexmesh = model->surfmesh.vertexmesh;
10889         rsurface.modelvertexmeshbuffer = model->surfmesh.vertexmeshbuffer;
10890         rsurface.modelvertexposition = model->surfmesh.vertexposition;
10891         rsurface.modelvertexpositionbuffer = model->surfmesh.vertexpositionbuffer;
10892         rsurface.modelgeneratedvertex = false;
10893         rsurface.batchgeneratedvertex = false;
10894         rsurface.batchfirstvertex = 0;
10895         rsurface.batchnumvertices = 0;
10896         rsurface.batchfirsttriangle = 0;
10897         rsurface.batchnumtriangles = 0;
10898         rsurface.batchvertex3f  = NULL;
10899         rsurface.batchvertex3f_vertexbuffer = NULL;
10900         rsurface.batchvertex3f_bufferoffset = 0;
10901         rsurface.batchsvector3f = NULL;
10902         rsurface.batchsvector3f_vertexbuffer = NULL;
10903         rsurface.batchsvector3f_bufferoffset = 0;
10904         rsurface.batchtvector3f = NULL;
10905         rsurface.batchtvector3f_vertexbuffer = NULL;
10906         rsurface.batchtvector3f_bufferoffset = 0;
10907         rsurface.batchnormal3f  = NULL;
10908         rsurface.batchnormal3f_vertexbuffer = NULL;
10909         rsurface.batchnormal3f_bufferoffset = 0;
10910         rsurface.batchlightmapcolor4f = NULL;
10911         rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
10912         rsurface.batchlightmapcolor4f_bufferoffset = 0;
10913         rsurface.batchtexcoordtexture2f = NULL;
10914         rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
10915         rsurface.batchtexcoordtexture2f_bufferoffset = 0;
10916         rsurface.batchtexcoordlightmap2f = NULL;
10917         rsurface.batchtexcoordlightmap2f_vertexbuffer = NULL;
10918         rsurface.batchtexcoordlightmap2f_bufferoffset = 0;
10919         rsurface.batchvertexmesh = NULL;
10920         rsurface.batchvertexmeshbuffer = NULL;
10921         rsurface.batchvertexposition = NULL;
10922         rsurface.batchvertexpositionbuffer = NULL;
10923         rsurface.batchelement3i = NULL;
10924         rsurface.batchelement3i_indexbuffer = NULL;
10925         rsurface.batchelement3i_bufferoffset = 0;
10926         rsurface.batchelement3s = NULL;
10927         rsurface.batchelement3s_indexbuffer = NULL;
10928         rsurface.batchelement3s_bufferoffset = 0;
10929         rsurface.passcolor4f = NULL;
10930         rsurface.passcolor4f_vertexbuffer = NULL;
10931         rsurface.passcolor4f_bufferoffset = 0;
10932 }
10933
10934 void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents, qboolean prepass)
10935 {
10936         dp_model_t *model = ent->model;
10937         //if (rsurface.entity == ent && (!model->surfmesh.isanimated || (!wantnormals && !wanttangents)))
10938         //      return;
10939         rsurface.entity = (entity_render_t *)ent;
10940         rsurface.skeleton = ent->skeleton;
10941         memcpy(rsurface.userwavefunc_param, ent->userwavefunc_param, sizeof(rsurface.userwavefunc_param));
10942         rsurface.ent_skinnum = ent->skinnum;
10943         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;
10944         rsurface.ent_shadertime = ent->shadertime;
10945         rsurface.ent_flags = ent->flags;
10946         R_Mesh_ResizeArrays(max(model->surfmesh.num_vertices, model->surfmesh.num_triangles));
10947         rsurface.matrix = ent->matrix;
10948         rsurface.inversematrix = ent->inversematrix;
10949         rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
10950         rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
10951         R_EntityMatrix(&rsurface.matrix);
10952         Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
10953         Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
10954         rsurface.fogplaneviewdist *= rsurface.inversematrixscale;
10955         rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
10956         rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
10957         rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
10958         VectorCopy(ent->modellight_ambient, rsurface.modellight_ambient);
10959         VectorCopy(ent->modellight_diffuse, rsurface.modellight_diffuse);
10960         VectorCopy(ent->modellight_lightdir, rsurface.modellight_lightdir);
10961         VectorCopy(ent->colormap_pantscolor, rsurface.colormap_pantscolor);
10962         VectorCopy(ent->colormap_shirtcolor, rsurface.colormap_shirtcolor);
10963         VectorScale(ent->colormod, r_refdef.view.colorscale, rsurface.colormod);
10964         rsurface.colormod[3] = ent->alpha;
10965         VectorScale(ent->glowmod, r_refdef.view.colorscale * r_hdr_glowintensity.value, rsurface.glowmod);
10966         memcpy(rsurface.frameblend, ent->frameblend, sizeof(ent->frameblend));
10967         rsurface.ent_alttextures = ent->framegroupblend[0].frame != 0;
10968         rsurface.basepolygonfactor = r_refdef.polygonfactor;
10969         rsurface.basepolygonoffset = r_refdef.polygonoffset;
10970         if (ent->model->brush.submodel && !prepass)
10971         {
10972                 rsurface.basepolygonfactor += r_polygonoffset_submodel_factor.value;
10973                 rsurface.basepolygonoffset += r_polygonoffset_submodel_offset.value;
10974         }
10975         if (model->surfmesh.isanimated && model->AnimateVertices && (rsurface.frameblend[0].lerp != 1 || rsurface.frameblend[0].subframe != 0))
10976         {
10977                 if (ent->animcache_vertex3f && !r_framedata_failed)
10978                 {
10979                         rsurface.modelvertex3f = ent->animcache_vertex3f;
10980                         rsurface.modelsvector3f = wanttangents ? ent->animcache_svector3f : NULL;
10981                         rsurface.modeltvector3f = wanttangents ? ent->animcache_tvector3f : NULL;
10982                         rsurface.modelnormal3f = wantnormals ? ent->animcache_normal3f : NULL;
10983                         rsurface.modelvertexmesh = ent->animcache_vertexmesh;
10984                         rsurface.modelvertexmeshbuffer = ent->animcache_vertexmeshbuffer;
10985                         rsurface.modelvertexposition = ent->animcache_vertexposition;
10986                         rsurface.modelvertexpositionbuffer = ent->animcache_vertexpositionbuffer;
10987                 }
10988                 else if (wanttangents)
10989                 {
10990                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
10991                         rsurface.modelsvector3f = rsurface.array_modelsvector3f;
10992                         rsurface.modeltvector3f = rsurface.array_modeltvector3f;
10993                         rsurface.modelnormal3f = rsurface.array_modelnormal3f;
10994                         model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f);
10995                         rsurface.modelvertexmesh = NULL;
10996                         rsurface.modelvertexmeshbuffer = NULL;
10997                         rsurface.modelvertexposition = NULL;
10998                         rsurface.modelvertexpositionbuffer = NULL;
10999                 }
11000                 else if (wantnormals)
11001                 {
11002                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
11003                         rsurface.modelsvector3f = NULL;
11004                         rsurface.modeltvector3f = NULL;
11005                         rsurface.modelnormal3f = rsurface.array_modelnormal3f;
11006                         model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, NULL, NULL);
11007                         rsurface.modelvertexmesh = NULL;
11008                         rsurface.modelvertexmeshbuffer = NULL;
11009                         rsurface.modelvertexposition = NULL;
11010                         rsurface.modelvertexpositionbuffer = NULL;
11011                 }
11012                 else
11013                 {
11014                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
11015                         rsurface.modelsvector3f = NULL;
11016                         rsurface.modeltvector3f = NULL;
11017                         rsurface.modelnormal3f = NULL;
11018                         model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, NULL, NULL, NULL);
11019                         rsurface.modelvertexmesh = NULL;
11020                         rsurface.modelvertexmeshbuffer = NULL;
11021                         rsurface.modelvertexposition = NULL;
11022                         rsurface.modelvertexpositionbuffer = NULL;
11023                 }
11024                 rsurface.modelvertex3f_vertexbuffer = 0;
11025                 rsurface.modelvertex3f_bufferoffset = 0;
11026                 rsurface.modelsvector3f_vertexbuffer = 0;
11027                 rsurface.modelsvector3f_bufferoffset = 0;
11028                 rsurface.modeltvector3f_vertexbuffer = 0;
11029                 rsurface.modeltvector3f_bufferoffset = 0;
11030                 rsurface.modelnormal3f_vertexbuffer = 0;
11031                 rsurface.modelnormal3f_bufferoffset = 0;
11032                 rsurface.modelgeneratedvertex = true;
11033         }
11034         else
11035         {
11036                 rsurface.modelvertex3f  = model->surfmesh.data_vertex3f;
11037                 rsurface.modelvertex3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
11038                 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
11039                 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
11040                 rsurface.modelsvector3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
11041                 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
11042                 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
11043                 rsurface.modeltvector3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
11044                 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
11045                 rsurface.modelnormal3f  = model->surfmesh.data_normal3f;
11046                 rsurface.modelnormal3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
11047                 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
11048                 rsurface.modelvertexmesh = model->surfmesh.vertexmesh;
11049                 rsurface.modelvertexmeshbuffer = model->surfmesh.vertexmeshbuffer;
11050                 rsurface.modelvertexposition = model->surfmesh.vertexposition;
11051                 rsurface.modelvertexpositionbuffer = model->surfmesh.vertexpositionbuffer;
11052                 rsurface.modelgeneratedvertex = false;
11053         }
11054         rsurface.modellightmapcolor4f  = model->surfmesh.data_lightmapcolor4f;
11055         rsurface.modellightmapcolor4f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
11056         rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
11057         rsurface.modeltexcoordtexture2f  = model->surfmesh.data_texcoordtexture2f;
11058         rsurface.modeltexcoordtexture2f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
11059         rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
11060         rsurface.modeltexcoordlightmap2f  = model->surfmesh.data_texcoordlightmap2f;
11061         rsurface.modeltexcoordlightmap2f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
11062         rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
11063         rsurface.modelelement3i = model->surfmesh.data_element3i;
11064         rsurface.modelelement3i_indexbuffer = model->surfmesh.data_element3i_indexbuffer;
11065         rsurface.modelelement3i_bufferoffset = model->surfmesh.data_element3i_bufferoffset;
11066         rsurface.modelelement3s = model->surfmesh.data_element3s;
11067         rsurface.modelelement3s_indexbuffer = model->surfmesh.data_element3s_indexbuffer;
11068         rsurface.modelelement3s_bufferoffset = model->surfmesh.data_element3s_bufferoffset;
11069         rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
11070         rsurface.modelnumvertices = model->surfmesh.num_vertices;
11071         rsurface.modelnumtriangles = model->surfmesh.num_triangles;
11072         rsurface.modelsurfaces = model->data_surfaces;
11073         rsurface.batchgeneratedvertex = false;
11074         rsurface.batchfirstvertex = 0;
11075         rsurface.batchnumvertices = 0;
11076         rsurface.batchfirsttriangle = 0;
11077         rsurface.batchnumtriangles = 0;
11078         rsurface.batchvertex3f  = NULL;
11079         rsurface.batchvertex3f_vertexbuffer = NULL;
11080         rsurface.batchvertex3f_bufferoffset = 0;
11081         rsurface.batchsvector3f = NULL;
11082         rsurface.batchsvector3f_vertexbuffer = NULL;
11083         rsurface.batchsvector3f_bufferoffset = 0;
11084         rsurface.batchtvector3f = NULL;
11085         rsurface.batchtvector3f_vertexbuffer = NULL;
11086         rsurface.batchtvector3f_bufferoffset = 0;
11087         rsurface.batchnormal3f  = NULL;
11088         rsurface.batchnormal3f_vertexbuffer = NULL;
11089         rsurface.batchnormal3f_bufferoffset = 0;
11090         rsurface.batchlightmapcolor4f = NULL;
11091         rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
11092         rsurface.batchlightmapcolor4f_bufferoffset = 0;
11093         rsurface.batchtexcoordtexture2f = NULL;
11094         rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
11095         rsurface.batchtexcoordtexture2f_bufferoffset = 0;
11096         rsurface.batchtexcoordlightmap2f = NULL;
11097         rsurface.batchtexcoordlightmap2f_vertexbuffer = NULL;
11098         rsurface.batchtexcoordlightmap2f_bufferoffset = 0;
11099         rsurface.batchvertexmesh = NULL;
11100         rsurface.batchvertexmeshbuffer = NULL;
11101         rsurface.batchvertexposition = NULL;
11102         rsurface.batchvertexpositionbuffer = NULL;
11103         rsurface.batchelement3i = NULL;
11104         rsurface.batchelement3i_indexbuffer = NULL;
11105         rsurface.batchelement3i_bufferoffset = 0;
11106         rsurface.batchelement3s = NULL;
11107         rsurface.batchelement3s_indexbuffer = NULL;
11108         rsurface.batchelement3s_bufferoffset = 0;
11109         rsurface.passcolor4f = NULL;
11110         rsurface.passcolor4f_vertexbuffer = NULL;
11111         rsurface.passcolor4f_bufferoffset = 0;
11112 }
11113
11114 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)
11115 {
11116         int i;
11117
11118         rsurface.entity = r_refdef.scene.worldentity;
11119         rsurface.skeleton = NULL;
11120         rsurface.ent_skinnum = 0;
11121         rsurface.ent_qwskin = -1;
11122         rsurface.ent_shadertime = shadertime;
11123         rsurface.ent_flags = entflags;
11124         rsurface.modelnumvertices = numvertices;
11125         rsurface.modelnumtriangles = numtriangles;
11126         R_Mesh_ResizeArrays(max(rsurface.modelnumvertices, rsurface.modelnumtriangles));
11127         rsurface.matrix = *matrix;
11128         rsurface.inversematrix = *inversematrix;
11129         rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
11130         rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
11131         R_EntityMatrix(&rsurface.matrix);
11132         Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
11133         Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
11134         rsurface.fogplaneviewdist *= rsurface.inversematrixscale;
11135         rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
11136         rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
11137         rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
11138         VectorSet(rsurface.modellight_ambient, 0, 0, 0);
11139         VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
11140         VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
11141         VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
11142         VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
11143         Vector4Set(rsurface.colormod, r * r_refdef.view.colorscale, g * r_refdef.view.colorscale, b * r_refdef.view.colorscale, a);
11144         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);
11145         memset(rsurface.frameblend, 0, sizeof(rsurface.frameblend));
11146         rsurface.frameblend[0].lerp = 1;
11147         rsurface.ent_alttextures = false;
11148         rsurface.basepolygonfactor = r_refdef.polygonfactor;
11149         rsurface.basepolygonoffset = r_refdef.polygonoffset;
11150         if (wanttangents)
11151         {
11152                 rsurface.modelvertex3f = vertex3f;
11153                 rsurface.modelsvector3f = svector3f ? svector3f : rsurface.array_modelsvector3f;
11154                 rsurface.modeltvector3f = tvector3f ? tvector3f : rsurface.array_modeltvector3f;
11155                 rsurface.modelnormal3f = normal3f ? normal3f : rsurface.array_modelnormal3f;
11156         }
11157         else if (wantnormals)
11158         {
11159                 rsurface.modelvertex3f = vertex3f;
11160                 rsurface.modelsvector3f = NULL;
11161                 rsurface.modeltvector3f = NULL;
11162                 rsurface.modelnormal3f = normal3f ? normal3f : rsurface.array_modelnormal3f;
11163         }
11164         else
11165         {
11166                 rsurface.modelvertex3f = vertex3f;
11167                 rsurface.modelsvector3f = NULL;
11168                 rsurface.modeltvector3f = NULL;
11169                 rsurface.modelnormal3f = NULL;
11170         }
11171         rsurface.modelvertexmesh = NULL;
11172         rsurface.modelvertexmeshbuffer = NULL;
11173         rsurface.modelvertexposition = NULL;
11174         rsurface.modelvertexpositionbuffer = NULL;
11175         rsurface.modelvertex3f_vertexbuffer = 0;
11176         rsurface.modelvertex3f_bufferoffset = 0;
11177         rsurface.modelsvector3f_vertexbuffer = 0;
11178         rsurface.modelsvector3f_bufferoffset = 0;
11179         rsurface.modeltvector3f_vertexbuffer = 0;
11180         rsurface.modeltvector3f_bufferoffset = 0;
11181         rsurface.modelnormal3f_vertexbuffer = 0;
11182         rsurface.modelnormal3f_bufferoffset = 0;
11183         rsurface.modelgeneratedvertex = true;
11184         rsurface.modellightmapcolor4f  = color4f;
11185         rsurface.modellightmapcolor4f_vertexbuffer = 0;
11186         rsurface.modellightmapcolor4f_bufferoffset = 0;
11187         rsurface.modeltexcoordtexture2f  = texcoord2f;
11188         rsurface.modeltexcoordtexture2f_vertexbuffer = 0;
11189         rsurface.modeltexcoordtexture2f_bufferoffset = 0;
11190         rsurface.modeltexcoordlightmap2f  = NULL;
11191         rsurface.modeltexcoordlightmap2f_vertexbuffer = 0;
11192         rsurface.modeltexcoordlightmap2f_bufferoffset = 0;
11193         rsurface.modelelement3i = element3i;
11194         rsurface.modelelement3i_indexbuffer = NULL;
11195         rsurface.modelelement3i_bufferoffset = 0;
11196         rsurface.modelelement3s = element3s;
11197         rsurface.modelelement3s_indexbuffer = NULL;
11198         rsurface.modelelement3s_bufferoffset = 0;
11199         rsurface.modellightmapoffsets = NULL;
11200         rsurface.modelsurfaces = NULL;
11201         rsurface.batchgeneratedvertex = false;
11202         rsurface.batchfirstvertex = 0;
11203         rsurface.batchnumvertices = 0;
11204         rsurface.batchfirsttriangle = 0;
11205         rsurface.batchnumtriangles = 0;
11206         rsurface.batchvertex3f  = NULL;
11207         rsurface.batchvertex3f_vertexbuffer = NULL;
11208         rsurface.batchvertex3f_bufferoffset = 0;
11209         rsurface.batchsvector3f = NULL;
11210         rsurface.batchsvector3f_vertexbuffer = NULL;
11211         rsurface.batchsvector3f_bufferoffset = 0;
11212         rsurface.batchtvector3f = NULL;
11213         rsurface.batchtvector3f_vertexbuffer = NULL;
11214         rsurface.batchtvector3f_bufferoffset = 0;
11215         rsurface.batchnormal3f  = NULL;
11216         rsurface.batchnormal3f_vertexbuffer = NULL;
11217         rsurface.batchnormal3f_bufferoffset = 0;
11218         rsurface.batchlightmapcolor4f = NULL;
11219         rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
11220         rsurface.batchlightmapcolor4f_bufferoffset = 0;
11221         rsurface.batchtexcoordtexture2f = NULL;
11222         rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
11223         rsurface.batchtexcoordtexture2f_bufferoffset = 0;
11224         rsurface.batchtexcoordlightmap2f = NULL;
11225         rsurface.batchtexcoordlightmap2f_vertexbuffer = NULL;
11226         rsurface.batchtexcoordlightmap2f_bufferoffset = 0;
11227         rsurface.batchvertexmesh = NULL;
11228         rsurface.batchvertexmeshbuffer = NULL;
11229         rsurface.batchvertexposition = NULL;
11230         rsurface.batchvertexpositionbuffer = NULL;
11231         rsurface.batchelement3i = NULL;
11232         rsurface.batchelement3i_indexbuffer = NULL;
11233         rsurface.batchelement3i_bufferoffset = 0;
11234         rsurface.batchelement3s = NULL;
11235         rsurface.batchelement3s_indexbuffer = NULL;
11236         rsurface.batchelement3s_bufferoffset = 0;
11237         rsurface.passcolor4f = NULL;
11238         rsurface.passcolor4f_vertexbuffer = NULL;
11239         rsurface.passcolor4f_bufferoffset = 0;
11240
11241         if (rsurface.modelnumvertices && rsurface.modelelement3i)
11242         {
11243                 if ((wantnormals || wanttangents) && !normal3f)
11244                 {
11245                         Mod_BuildNormals(0, rsurface.modelnumvertices, rsurface.modelnumtriangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer != 0);
11246                         rsurface.modelnormal3f = rsurface.array_modelnormal3f;
11247                 }
11248                 if (wanttangents && !svector3f)
11249                 {
11250                         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);
11251                         rsurface.modelsvector3f = rsurface.array_modelsvector3f;
11252                         rsurface.modeltvector3f = rsurface.array_modeltvector3f;
11253                 }
11254         }
11255
11256         // now convert arrays into vertexmesh structs
11257         for (i = 0;i < numvertices;i++)
11258         {
11259                 VectorCopy(rsurface.modelvertex3f + 3*i, rsurface.array_modelvertexposition[i].vertex3f);
11260                 VectorCopy(rsurface.modelvertex3f + 3*i, rsurface.array_modelvertexmesh[i].vertex3f);
11261                 if (rsurface.modelsvector3f)
11262                         VectorCopy(rsurface.modelsvector3f + 3*i, rsurface.array_modelvertexmesh[i].svector3f);
11263                 if (rsurface.modeltvector3f)
11264                         VectorCopy(rsurface.modeltvector3f + 3*i, rsurface.array_modelvertexmesh[i].tvector3f);
11265                 if (rsurface.modelnormal3f)
11266                         VectorCopy(rsurface.modelnormal3f + 3*i, rsurface.array_modelvertexmesh[i].normal3f);
11267                 if (rsurface.modellightmapcolor4f)
11268                         Vector4Scale(rsurface.modellightmapcolor4f + 4*i, 255.0f, rsurface.array_modelvertexmesh[i].color4ub);
11269                 if (rsurface.modeltexcoordtexture2f)
11270                         Vector2Copy(rsurface.modeltexcoordtexture2f + 2*i, rsurface.array_modelvertexmesh[i].texcoordtexture2f);
11271                 if (rsurface.modeltexcoordlightmap2f)
11272                         Vector2Copy(rsurface.modeltexcoordlightmap2f + 2*i, rsurface.array_modelvertexmesh[i].texcoordlightmap2f);
11273         }
11274 }
11275
11276 float RSurf_FogPoint(const float *v)
11277 {
11278         // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
11279         float FogPlaneViewDist = r_refdef.fogplaneviewdist;
11280         float FogPlaneVertexDist = DotProduct(r_refdef.fogplane, v) + r_refdef.fogplane[3];
11281         float FogHeightFade = r_refdef.fogheightfade;
11282         float fogfrac;
11283         unsigned int fogmasktableindex;
11284         if (r_refdef.fogplaneviewabove)
11285                 fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
11286         else
11287                 fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
11288         fogmasktableindex = (unsigned int)(VectorDistance(r_refdef.view.origin, v) * fogfrac * r_refdef.fogmasktabledistmultiplier);
11289         return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
11290 }
11291
11292 float RSurf_FogVertex(const float *v)
11293 {
11294         // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
11295         float FogPlaneViewDist = rsurface.fogplaneviewdist;
11296         float FogPlaneVertexDist = DotProduct(rsurface.fogplane, v) + rsurface.fogplane[3];
11297         float FogHeightFade = rsurface.fogheightfade;
11298         float fogfrac;
11299         unsigned int fogmasktableindex;
11300         if (r_refdef.fogplaneviewabove)
11301                 fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
11302         else
11303                 fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
11304         fogmasktableindex = (unsigned int)(VectorDistance(rsurface.localvieworigin, v) * fogfrac * rsurface.fogmasktabledistmultiplier);
11305         return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
11306 }
11307
11308 void RSurf_RenumberElements(const int *inelement3i, int *outelement3i, int numelements, int adjust)
11309 {
11310         int i;
11311         for (i = 0;i < numelements;i++)
11312                 outelement3i[i] = inelement3i[i] + adjust;
11313 }
11314
11315 static const int quadedges[6][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}};
11316 extern cvar_t gl_vbo;
11317 void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const msurface_t **texturesurfacelist)
11318 {
11319         int deformindex;
11320         int firsttriangle;
11321         int numtriangles;
11322         int firstvertex;
11323         int endvertex;
11324         int numvertices;
11325         int surfacefirsttriangle;
11326         int surfacenumtriangles;
11327         int surfacefirstvertex;
11328         int surfaceendvertex;
11329         int surfacenumvertices;
11330         int needsupdate;
11331         int i, j;
11332         qboolean gaps;
11333         qboolean dynamicvertex;
11334         float amplitude;
11335         float animpos;
11336         float scale;
11337         float center[3], forward[3], right[3], up[3], v[3], newforward[3], newright[3], newup[3];
11338         float waveparms[4];
11339         q3shaderinfo_deform_t *deform;
11340         const msurface_t *surface, *firstsurface;
11341         r_vertexposition_t *vertexposition;
11342         r_vertexmesh_t *vertexmesh;
11343         if (!texturenumsurfaces)
11344                 return;
11345         // find vertex range of this surface batch
11346         gaps = false;
11347         firstsurface = texturesurfacelist[0];
11348         firsttriangle = firstsurface->num_firsttriangle;
11349         numtriangles = 0;
11350         firstvertex = endvertex = firstsurface->num_firstvertex;
11351         for (i = 0;i < texturenumsurfaces;i++)
11352         {
11353                 surface = texturesurfacelist[i];
11354                 if (surface != firstsurface + i)
11355                         gaps = true;
11356                 surfacefirstvertex = surface->num_firstvertex;
11357                 surfaceendvertex = surfacefirstvertex + surface->num_vertices;
11358                 surfacenumtriangles = surface->num_triangles;
11359                 if (firstvertex > surfacefirstvertex)
11360                         firstvertex = surfacefirstvertex;
11361                 if (endvertex < surfaceendvertex)
11362                         endvertex = surfaceendvertex;
11363                 numtriangles += surfacenumtriangles;
11364         }
11365         if (!numtriangles)
11366                 return;
11367
11368         // we now know the vertex range used, and if there are any gaps in it
11369         rsurface.batchfirstvertex = firstvertex;
11370         rsurface.batchnumvertices = endvertex - firstvertex;
11371         rsurface.batchfirsttriangle = firsttriangle;
11372         rsurface.batchnumtriangles = numtriangles;
11373
11374         // this variable holds flags for which properties have been updated that
11375         // may require regenerating vertexmesh or vertexposition arrays...
11376         needsupdate = 0;
11377
11378         // check if any dynamic vertex processing must occur
11379         dynamicvertex = false;
11380
11381         if ((batchneed & (BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_ARRAY_VERTEXCOLOR)) && texturesurfacelist[0]->lightmapinfo)
11382                 needsupdate |= BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_NOGAPS;
11383         for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform;deformindex++, deform++)
11384         {
11385                 switch (deform->deform)
11386                 {
11387                 default:
11388                 case Q3DEFORM_PROJECTIONSHADOW:
11389                 case Q3DEFORM_TEXT0:
11390                 case Q3DEFORM_TEXT1:
11391                 case Q3DEFORM_TEXT2:
11392                 case Q3DEFORM_TEXT3:
11393                 case Q3DEFORM_TEXT4:
11394                 case Q3DEFORM_TEXT5:
11395                 case Q3DEFORM_TEXT6:
11396                 case Q3DEFORM_TEXT7:
11397                 case Q3DEFORM_NONE:
11398                         break;
11399                 case Q3DEFORM_AUTOSPRITE:
11400                         dynamicvertex = true;
11401                         batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS;
11402                         needsupdate |= BATCHNEED_VERTEXPOSITION | BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
11403                         break;
11404                 case Q3DEFORM_AUTOSPRITE2:
11405                         dynamicvertex = true;
11406                         batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS;
11407                         needsupdate |= BATCHNEED_VERTEXPOSITION | BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
11408                         break;
11409                 case Q3DEFORM_NORMAL:
11410                         dynamicvertex = true;
11411                         batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS;
11412                         needsupdate |= BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
11413                         break;
11414                 case Q3DEFORM_WAVE:
11415                         if(!R_TestQ3WaveFunc(deform->wavefunc, deform->waveparms))
11416                                 break; // if wavefunc is a nop, ignore this transform
11417                         dynamicvertex = true;
11418                         batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS;
11419                         needsupdate |= BATCHNEED_VERTEXPOSITION | BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
11420                         break;
11421                 case Q3DEFORM_BULGE:
11422                         dynamicvertex = true;
11423                         batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS;
11424                         needsupdate |= BATCHNEED_VERTEXPOSITION | BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
11425                         break;
11426                 case Q3DEFORM_MOVE:
11427                         if(!R_TestQ3WaveFunc(deform->wavefunc, deform->waveparms))
11428                                 break; // if wavefunc is a nop, ignore this transform
11429                         dynamicvertex = true;
11430                         batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS;
11431                         needsupdate |= BATCHNEED_VERTEXPOSITION | BATCHNEED_VERTEXMESH_VERTEX;
11432                         break;
11433                 }
11434         }
11435         switch(rsurface.texture->tcgen.tcgen)
11436         {
11437         default:
11438         case Q3TCGEN_TEXTURE:
11439                 break;
11440         case Q3TCGEN_LIGHTMAP:
11441                 dynamicvertex = true;
11442                 batchneed |= BATCHNEED_ARRAY_LIGHTMAP | BATCHNEED_NOGAPS;
11443                 needsupdate |= BATCHNEED_VERTEXMESH_LIGHTMAP;
11444                 break;
11445         case Q3TCGEN_VECTOR:
11446                 dynamicvertex = true;
11447                 batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS;
11448                 needsupdate |= BATCHNEED_VERTEXMESH_TEXCOORD;
11449                 break;
11450         case Q3TCGEN_ENVIRONMENT:
11451                 dynamicvertex = true;
11452                 batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_NOGAPS;
11453                 needsupdate |= BATCHNEED_VERTEXMESH_TEXCOORD;
11454                 break;
11455         }
11456         if (rsurface.texture->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
11457         {
11458                 dynamicvertex = true;
11459                 batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS;
11460                 needsupdate |= BATCHNEED_VERTEXMESH_TEXCOORD;
11461         }
11462
11463         if (!rsurface.modelvertexmesh && (batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP)))
11464         {
11465                 dynamicvertex = true;
11466                 batchneed |= BATCHNEED_NOGAPS;
11467                 needsupdate |= (batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP));
11468         }
11469
11470         if (needsupdate & batchneed & BATCHNEED_VERTEXPOSITION)
11471         {
11472                 dynamicvertex = true;
11473                 batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS;
11474                 needsupdate |= (batchneed & BATCHNEED_VERTEXPOSITION);
11475         }
11476
11477         if (dynamicvertex || gaps || rsurface.batchfirstvertex)
11478         {
11479                 // when copying, we need to consider the regeneration of vertexmesh, any dependencies it may have must be set...
11480                 if (batchneed & BATCHNEED_VERTEXMESH_VERTEX)      batchneed |= BATCHNEED_ARRAY_VERTEX;
11481                 if (batchneed & BATCHNEED_VERTEXMESH_NORMAL)      batchneed |= BATCHNEED_ARRAY_NORMAL;
11482                 if (batchneed & BATCHNEED_VERTEXMESH_VECTOR)      batchneed |= BATCHNEED_ARRAY_VECTOR;
11483                 if (batchneed & BATCHNEED_VERTEXMESH_VERTEXCOLOR) batchneed |= BATCHNEED_ARRAY_VERTEXCOLOR;
11484                 if (batchneed & BATCHNEED_VERTEXMESH_TEXCOORD)    batchneed |= BATCHNEED_ARRAY_TEXCOORD;
11485                 if (batchneed & BATCHNEED_VERTEXMESH_LIGHTMAP)    batchneed |= BATCHNEED_ARRAY_LIGHTMAP;
11486         }
11487
11488         // when the model data has no vertex buffer (dynamic mesh), we need to
11489         // eliminate gaps
11490         if (!rsurface.modelvertexmeshbuffer)
11491                 batchneed |= BATCHNEED_NOGAPS;
11492
11493         // if needsupdate, we have to do a dynamic vertex batch for sure
11494         if (needsupdate & batchneed)
11495                 dynamicvertex = true;
11496
11497         // see if we need to build vertexmesh from arrays
11498         if (!rsurface.modelvertexmesh && (batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP)))
11499                 dynamicvertex = true;
11500
11501         // see if we need to build vertexposition from arrays
11502         if (!rsurface.modelvertexposition && (batchneed & BATCHNEED_VERTEXPOSITION))
11503                 dynamicvertex = true;
11504
11505         // if gaps are unacceptable, and there are gaps, it's a dynamic batch...
11506         if ((batchneed & BATCHNEED_NOGAPS) && (gaps || firstvertex))
11507                 dynamicvertex = true;
11508
11509         // if there is a chance of animated vertex colors, it's a dynamic batch
11510         if ((batchneed & (BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_ARRAY_VERTEXCOLOR)) && texturesurfacelist[0]->lightmapinfo)
11511                 dynamicvertex = true;
11512
11513         rsurface.batchvertex3f = rsurface.modelvertex3f;
11514         rsurface.batchvertex3f_vertexbuffer = rsurface.modelvertex3f_vertexbuffer;
11515         rsurface.batchvertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
11516         rsurface.batchsvector3f = rsurface.modelsvector3f;
11517         rsurface.batchsvector3f_vertexbuffer = rsurface.modelsvector3f_vertexbuffer;
11518         rsurface.batchsvector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
11519         rsurface.batchtvector3f = rsurface.modeltvector3f;
11520         rsurface.batchtvector3f_vertexbuffer = rsurface.modeltvector3f_vertexbuffer;
11521         rsurface.batchtvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
11522         rsurface.batchnormal3f = rsurface.modelnormal3f;
11523         rsurface.batchnormal3f_vertexbuffer = rsurface.modelnormal3f_vertexbuffer;
11524         rsurface.batchnormal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
11525         rsurface.batchlightmapcolor4f = rsurface.modellightmapcolor4f;
11526         rsurface.batchlightmapcolor4f_vertexbuffer  = rsurface.modellightmapcolor4f_vertexbuffer;
11527         rsurface.batchlightmapcolor4f_bufferoffset  = rsurface.modellightmapcolor4f_bufferoffset;
11528         rsurface.batchtexcoordtexture2f = rsurface.modeltexcoordtexture2f;
11529         rsurface.batchtexcoordtexture2f_vertexbuffer  = rsurface.modeltexcoordtexture2f_vertexbuffer;
11530         rsurface.batchtexcoordtexture2f_bufferoffset  = rsurface.modeltexcoordtexture2f_bufferoffset;
11531         rsurface.batchtexcoordlightmap2f = rsurface.modeltexcoordlightmap2f;
11532         rsurface.batchtexcoordlightmap2f_vertexbuffer = rsurface.modeltexcoordlightmap2f_vertexbuffer;
11533         rsurface.batchtexcoordlightmap2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
11534         rsurface.batchvertexposition = rsurface.modelvertexposition;
11535         rsurface.batchvertexpositionbuffer = rsurface.modelvertexpositionbuffer;
11536         rsurface.batchvertexmesh = rsurface.modelvertexmesh;
11537         rsurface.batchvertexmeshbuffer = rsurface.modelvertexmeshbuffer;
11538         rsurface.batchelement3i = rsurface.modelelement3i;
11539         rsurface.batchelement3i_indexbuffer = rsurface.modelelement3i_indexbuffer;
11540         rsurface.batchelement3i_bufferoffset = rsurface.modelelement3i_bufferoffset;
11541         rsurface.batchelement3s = rsurface.modelelement3s;
11542         rsurface.batchelement3s_indexbuffer = rsurface.modelelement3s_indexbuffer;
11543         rsurface.batchelement3s_bufferoffset = rsurface.modelelement3s_bufferoffset;
11544
11545         // if any dynamic vertex processing has to occur in software, we copy the
11546         // entire surface list together before processing to rebase the vertices
11547         // to start at 0 (otherwise we waste a lot of room in a vertex buffer).
11548         //
11549         // if any gaps exist and we do not have a static vertex buffer, we have to
11550         // copy the surface list together to avoid wasting upload bandwidth on the
11551         // vertices in the gaps.
11552         //
11553         // if gaps exist and we have a static vertex buffer, we still have to
11554         // combine the index buffer ranges into one dynamic index buffer.
11555         //
11556         // in all cases we end up with data that can be drawn in one call.
11557
11558         if (!dynamicvertex)
11559         {
11560                 // static vertex data, just set pointers...
11561                 rsurface.batchgeneratedvertex = false;
11562                 // if there are gaps, we want to build a combined index buffer,
11563                 // otherwise use the original static buffer with an appropriate offset
11564                 if (gaps)
11565                 {
11566                         firsttriangle = 0;
11567                         numtriangles = 0;
11568                         for (i = 0;i < texturenumsurfaces;i++)
11569                         {
11570                                 surfacefirsttriangle = texturesurfacelist[i]->num_firsttriangle;
11571                                 surfacenumtriangles = texturesurfacelist[i]->num_triangles;
11572                                 memcpy(rsurface.array_batchelement3i + 3*numtriangles, rsurface.modelelement3i + 3*surfacefirsttriangle, surfacenumtriangles*sizeof(int[3]));
11573                                 numtriangles += surfacenumtriangles;
11574                         }
11575                         rsurface.batchelement3i = rsurface.array_batchelement3i;
11576                         rsurface.batchelement3i_indexbuffer = NULL;
11577                         rsurface.batchelement3i_bufferoffset = 0;
11578                         rsurface.batchelement3s = NULL;
11579                         rsurface.batchelement3s_indexbuffer = NULL;
11580                         rsurface.batchelement3s_bufferoffset = 0;
11581                         if (endvertex <= 65536)
11582                         {
11583                                 rsurface.batchelement3s = rsurface.array_batchelement3s;
11584                                 for (i = 0;i < numtriangles*3;i++)
11585                                         rsurface.array_batchelement3s[i] = rsurface.array_batchelement3i[i];
11586                         }
11587                         rsurface.batchfirsttriangle = firsttriangle;
11588                         rsurface.batchnumtriangles = numtriangles;
11589                 }
11590                 return;
11591         }
11592
11593         // something needs software processing, do it for real...
11594         // we only directly handle interleaved array data in this case...
11595         rsurface.batchgeneratedvertex = true;
11596
11597         // now copy the vertex data into a combined array and make an index array
11598         // (this is what Quake3 does all the time)
11599         //if (gaps || rsurface.batchfirstvertex)
11600         {
11601                 rsurface.batchvertexposition = NULL;
11602                 rsurface.batchvertexpositionbuffer = NULL;
11603                 rsurface.batchvertexmesh = NULL;
11604                 rsurface.batchvertexmeshbuffer = NULL;
11605                 rsurface.batchvertex3f = NULL;
11606                 rsurface.batchvertex3f_vertexbuffer = NULL;
11607                 rsurface.batchvertex3f_bufferoffset = 0;
11608                 rsurface.batchsvector3f = NULL;
11609                 rsurface.batchsvector3f_vertexbuffer = NULL;
11610                 rsurface.batchsvector3f_bufferoffset = 0;
11611                 rsurface.batchtvector3f = NULL;
11612                 rsurface.batchtvector3f_vertexbuffer = NULL;
11613                 rsurface.batchtvector3f_bufferoffset = 0;
11614                 rsurface.batchnormal3f = NULL;
11615                 rsurface.batchnormal3f_vertexbuffer = NULL;
11616                 rsurface.batchnormal3f_bufferoffset = 0;
11617                 rsurface.batchlightmapcolor4f = NULL;
11618                 rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
11619                 rsurface.batchlightmapcolor4f_bufferoffset = 0;
11620                 rsurface.batchtexcoordtexture2f = NULL;
11621                 rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
11622                 rsurface.batchtexcoordtexture2f_bufferoffset = 0;
11623                 rsurface.batchtexcoordlightmap2f = NULL;
11624                 rsurface.batchtexcoordlightmap2f_vertexbuffer = NULL;
11625                 rsurface.batchtexcoordlightmap2f_bufferoffset = 0;
11626                 rsurface.batchelement3i = rsurface.array_batchelement3i;
11627                 rsurface.batchelement3i_indexbuffer = NULL;
11628                 rsurface.batchelement3i_bufferoffset = 0;
11629                 rsurface.batchelement3s = NULL;
11630                 rsurface.batchelement3s_indexbuffer = NULL;
11631                 rsurface.batchelement3s_bufferoffset = 0;
11632                 // we'll only be setting up certain arrays as needed
11633                 if (batchneed & BATCHNEED_VERTEXPOSITION)
11634                         rsurface.batchvertexposition = rsurface.array_batchvertexposition;
11635                 if (batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP))
11636                         rsurface.batchvertexmesh = rsurface.array_batchvertexmesh;
11637                 if (batchneed & BATCHNEED_ARRAY_VERTEX)
11638                         rsurface.batchvertex3f = rsurface.array_batchvertex3f;
11639                 if (batchneed & BATCHNEED_ARRAY_NORMAL)
11640                         rsurface.batchnormal3f = rsurface.array_batchnormal3f;
11641                 if (batchneed & BATCHNEED_ARRAY_VECTOR)
11642                 {
11643                         rsurface.batchsvector3f = rsurface.array_batchsvector3f;
11644                         rsurface.batchtvector3f = rsurface.array_batchtvector3f;
11645                 }
11646                 if (batchneed & BATCHNEED_ARRAY_VERTEXCOLOR)
11647                         rsurface.batchlightmapcolor4f = rsurface.array_batchlightmapcolor4f;
11648                 if (batchneed & BATCHNEED_ARRAY_TEXCOORD)
11649                         rsurface.batchtexcoordtexture2f = rsurface.array_batchtexcoordtexture2f;
11650                 if (batchneed & BATCHNEED_ARRAY_LIGHTMAP)
11651                         rsurface.batchtexcoordlightmap2f = rsurface.array_batchtexcoordlightmap2f;
11652                 numvertices = 0;
11653                 numtriangles = 0;
11654                 for (i = 0;i < texturenumsurfaces;i++)
11655                 {
11656                         surfacefirstvertex = texturesurfacelist[i]->num_firstvertex;
11657                         surfacenumvertices = texturesurfacelist[i]->num_vertices;
11658                         surfacefirsttriangle = texturesurfacelist[i]->num_firsttriangle;
11659                         surfacenumtriangles = texturesurfacelist[i]->num_triangles;
11660                         // copy only the data requested
11661                         if ((batchneed & BATCHNEED_VERTEXPOSITION) && rsurface.modelvertexposition)
11662                                 memcpy(rsurface.array_batchvertexposition + numvertices, rsurface.modelvertexposition + surfacefirstvertex, surfacenumvertices * sizeof(rsurface.batchvertexposition[0]));
11663                         if ((batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP)) && rsurface.modelvertexmesh)
11664                                 memcpy(rsurface.array_batchvertexmesh + numvertices, rsurface.modelvertexmesh + surfacefirstvertex, surfacenumvertices * sizeof(rsurface.batchvertexmesh[0]));
11665                         if (batchneed & (BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | BATCHNEED_ARRAY_VERTEXCOLOR | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_ARRAY_LIGHTMAP))
11666                         {
11667                                 if (batchneed & BATCHNEED_ARRAY_VERTEX)
11668                                         memcpy(rsurface.array_batchvertex3f + 3*numvertices, rsurface.modelvertex3f + 3*surfacefirstvertex, surfacenumvertices * sizeof(float[3]));
11669                                 if ((batchneed & BATCHNEED_ARRAY_NORMAL) && rsurface.modelnormal3f)
11670                                         memcpy(rsurface.array_batchnormal3f + 3*numvertices, rsurface.modelnormal3f + 3*surfacefirstvertex, surfacenumvertices * sizeof(float[3]));
11671                                 if ((batchneed & BATCHNEED_ARRAY_VECTOR) && rsurface.modelsvector3f)
11672                                 {
11673                                         memcpy(rsurface.array_batchsvector3f + 3*numvertices, rsurface.modelsvector3f + 3*surfacefirstvertex, surfacenumvertices * sizeof(float[3]));
11674                                         memcpy(rsurface.array_batchtvector3f + 3*numvertices, rsurface.modeltvector3f + 3*surfacefirstvertex, surfacenumvertices * sizeof(float[3]));
11675                                 }
11676                                 if ((batchneed & BATCHNEED_ARRAY_VERTEXCOLOR) && rsurface.modellightmapcolor4f)
11677                                         memcpy(rsurface.array_batchlightmapcolor4f + 4*numvertices, rsurface.modellightmapcolor4f + 4*surfacefirstvertex, surfacenumvertices * sizeof(float[4]));
11678                                 if ((batchneed & BATCHNEED_ARRAY_TEXCOORD) && rsurface.modeltexcoordtexture2f)
11679                                         memcpy(rsurface.array_batchtexcoordtexture2f + 2*numvertices, rsurface.modeltexcoordtexture2f + 2*surfacefirstvertex, surfacenumvertices * sizeof(float[2]));
11680                                 if ((batchneed & BATCHNEED_ARRAY_LIGHTMAP) && rsurface.modeltexcoordlightmap2f)
11681                                         memcpy(rsurface.array_batchtexcoordlightmap2f + 2*numvertices, rsurface.modeltexcoordlightmap2f + 2*surfacefirstvertex, surfacenumvertices * sizeof(float[2]));
11682                         }
11683                         RSurf_RenumberElements(rsurface.modelelement3i + 3*surfacefirsttriangle, rsurface.array_batchelement3i + 3*numtriangles, 3*surfacenumtriangles, numvertices - surfacefirstvertex);
11684                         numvertices += surfacenumvertices;
11685                         numtriangles += surfacenumtriangles;
11686                 }
11687
11688                 // generate a 16bit index array as well if possible
11689                 // (in general, dynamic batches fit)
11690                 if (numvertices <= 65536)
11691                 {
11692                         rsurface.batchelement3s = rsurface.array_batchelement3s;
11693                         for (i = 0;i < numtriangles*3;i++)
11694                                 rsurface.array_batchelement3s[i] = rsurface.array_batchelement3i[i];
11695                 }
11696
11697                 // since we've copied everything, the batch now starts at 0
11698                 rsurface.batchfirstvertex = 0;
11699                 rsurface.batchnumvertices = numvertices;
11700                 rsurface.batchfirsttriangle = 0;
11701                 rsurface.batchnumtriangles = numtriangles;
11702         }
11703
11704         // q1bsp surfaces rendered in vertex color mode have to have colors
11705         // calculated based on lightstyles
11706         if ((batchneed & (BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_ARRAY_VERTEXCOLOR)) && texturesurfacelist[0]->lightmapinfo)
11707         {
11708                 // generate color arrays for the surfaces in this list
11709                 int c[4];
11710                 int scale;
11711                 int size3;
11712                 const int *offsets;
11713                 const unsigned char *lm;
11714                 numvertices = 0;
11715                 rsurface.batchlightmapcolor4f = rsurface.array_batchlightmapcolor4f;
11716                 rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
11717                 rsurface.batchlightmapcolor4f_bufferoffset = 0;
11718                 for (i = 0;i < texturenumsurfaces;i++)
11719                 {
11720                         surface = texturesurfacelist[i];
11721                         offsets = rsurface.modellightmapoffsets + surface->num_firstvertex;
11722                         surfacenumvertices = surface->num_vertices;
11723                         if (surface->lightmapinfo->samples)
11724                         {
11725                                 for (j = 0;j < surfacenumvertices;j++)
11726                                 {
11727                                         lm = surface->lightmapinfo->samples + offsets[j];
11728                                         scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[0]];
11729                                         VectorScale(lm, scale, c);
11730                                         if (surface->lightmapinfo->styles[1] != 255)
11731                                         {
11732                                                 size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
11733                                                 lm += size3;
11734                                                 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[1]];
11735                                                 VectorMA(c, scale, lm, c);
11736                                                 if (surface->lightmapinfo->styles[2] != 255)
11737                                                 {
11738                                                         lm += size3;
11739                                                         scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[2]];
11740                                                         VectorMA(c, scale, lm, c);
11741                                                         if (surface->lightmapinfo->styles[3] != 255)
11742                                                         {
11743                                                                 lm += size3;
11744                                                                 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[3]];
11745                                                                 VectorMA(c, scale, lm, c);
11746                                                         }
11747                                                 }
11748                                         }
11749                                         c[0] >>= 15;
11750                                         c[1] >>= 15;
11751                                         c[2] >>= 15;
11752                                         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);
11753                                         numvertices++;
11754                                 }
11755                         }
11756                         else
11757                         {
11758                                 for (j = 0;j < surfacenumvertices;j++)
11759                                 {
11760                                         Vector4Set(rsurface.array_batchlightmapcolor4f + 4*numvertices, 0, 0, 0, 1);
11761                                         numvertices++;
11762                                 }
11763                         }
11764                 }
11765         }
11766
11767         // if vertices are deformed (sprite flares and things in maps, possibly
11768         // water waves, bulges and other deformations), modify the copied vertices
11769         // in place
11770         for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform;deformindex++, deform++)
11771         {
11772                 switch (deform->deform)
11773                 {
11774                 default:
11775                 case Q3DEFORM_PROJECTIONSHADOW:
11776                 case Q3DEFORM_TEXT0:
11777                 case Q3DEFORM_TEXT1:
11778                 case Q3DEFORM_TEXT2:
11779                 case Q3DEFORM_TEXT3:
11780                 case Q3DEFORM_TEXT4:
11781                 case Q3DEFORM_TEXT5:
11782                 case Q3DEFORM_TEXT6:
11783                 case Q3DEFORM_TEXT7:
11784                 case Q3DEFORM_NONE:
11785                         break;
11786                 case Q3DEFORM_AUTOSPRITE:
11787                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
11788                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
11789                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
11790                         VectorNormalize(newforward);
11791                         VectorNormalize(newright);
11792                         VectorNormalize(newup);
11793                         // a single autosprite surface can contain multiple sprites...
11794                         for (j = 0;j < rsurface.batchnumvertices - 3;j += 4)
11795                         {
11796                                 VectorClear(center);
11797                                 for (i = 0;i < 4;i++)
11798                                         VectorAdd(center, rsurface.batchvertex3f + 3*(j+i), center);
11799                                 VectorScale(center, 0.25f, center);
11800                                 VectorCopy(rsurface.batchnormal3f + 3*j, forward);
11801                                 VectorCopy(rsurface.batchsvector3f + 3*j, right);
11802                                 VectorCopy(rsurface.batchtvector3f + 3*j, up);
11803                                 for (i = 0;i < 4;i++)
11804                                 {
11805                                         VectorSubtract(rsurface.batchvertex3f + 3*(j+i), center, v);
11806                                         VectorMAMAMAM(1, center, DotProduct(forward, v), newforward, DotProduct(right, v), newright, DotProduct(up, v), newup, rsurface.array_batchvertex3f + 3*(j+i));
11807                                 }
11808                         }
11809                         // if we get here, BATCHNEED_ARRAY_NORMAL and BATCHNEED_ARRAY_VECTOR are in batchneed, so no need to check
11810                         Mod_BuildNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchnormal3f, true);
11811                         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);
11812                         rsurface.batchvertex3f = rsurface.array_batchvertex3f;
11813                         rsurface.batchvertex3f_vertexbuffer = NULL;
11814                         rsurface.batchvertex3f_bufferoffset = 0;
11815                         rsurface.batchsvector3f = rsurface.array_batchsvector3f;
11816                         rsurface.batchsvector3f_vertexbuffer = NULL;
11817                         rsurface.batchsvector3f_bufferoffset = 0;
11818                         rsurface.batchtvector3f = rsurface.array_batchtvector3f;
11819                         rsurface.batchtvector3f_vertexbuffer = NULL;
11820                         rsurface.batchtvector3f_bufferoffset = 0;
11821                         rsurface.batchnormal3f = rsurface.array_batchnormal3f;
11822                         rsurface.batchnormal3f_vertexbuffer = NULL;
11823                         rsurface.batchnormal3f_bufferoffset = 0;
11824                         break;
11825                 case Q3DEFORM_AUTOSPRITE2:
11826                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
11827                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
11828                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
11829                         VectorNormalize(newforward);
11830                         VectorNormalize(newright);
11831                         VectorNormalize(newup);
11832                         {
11833                                 const float *v1, *v2;
11834                                 vec3_t start, end;
11835                                 float f, l;
11836                                 struct
11837                                 {
11838                                         float length2;
11839                                         const float *v1;
11840                                         const float *v2;
11841                                 }
11842                                 shortest[2];
11843                                 memset(shortest, 0, sizeof(shortest));
11844                                 // a single autosprite surface can contain multiple sprites...
11845                                 for (j = 0;j < rsurface.batchnumvertices - 3;j += 4)
11846                                 {
11847                                         VectorClear(center);
11848                                         for (i = 0;i < 4;i++)
11849                                                 VectorAdd(center, rsurface.batchvertex3f + 3*(j+i), center);
11850                                         VectorScale(center, 0.25f, center);
11851                                         // find the two shortest edges, then use them to define the
11852                                         // axis vectors for rotating around the central axis
11853                                         for (i = 0;i < 6;i++)
11854                                         {
11855                                                 v1 = rsurface.batchvertex3f + 3*(j+quadedges[i][0]);
11856                                                 v2 = rsurface.batchvertex3f + 3*(j+quadedges[i][1]);
11857                                                 l = VectorDistance2(v1, v2);
11858                                                 // this length bias tries to make sense of square polygons, assuming they are meant to be upright
11859                                                 if (v1[2] != v2[2])
11860                                                         l += (1.0f / 1024.0f);
11861                                                 if (shortest[0].length2 > l || i == 0)
11862                                                 {
11863                                                         shortest[1] = shortest[0];
11864                                                         shortest[0].length2 = l;
11865                                                         shortest[0].v1 = v1;
11866                                                         shortest[0].v2 = v2;
11867                                                 }
11868                                                 else if (shortest[1].length2 > l || i == 1)
11869                                                 {
11870                                                         shortest[1].length2 = l;
11871                                                         shortest[1].v1 = v1;
11872                                                         shortest[1].v2 = v2;
11873                                                 }
11874                                         }
11875                                         VectorLerp(shortest[0].v1, 0.5f, shortest[0].v2, start);
11876                                         VectorLerp(shortest[1].v1, 0.5f, shortest[1].v2, end);
11877                                         // this calculates the right vector from the shortest edge
11878                                         // and the up vector from the edge midpoints
11879                                         VectorSubtract(shortest[0].v1, shortest[0].v2, right);
11880                                         VectorNormalize(right);
11881                                         VectorSubtract(end, start, up);
11882                                         VectorNormalize(up);
11883                                         // calculate a forward vector to use instead of the original plane normal (this is how we get a new right vector)
11884                                         VectorSubtract(rsurface.localvieworigin, center, forward);
11885                                         //Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, forward);
11886                                         VectorNegate(forward, forward);
11887                                         VectorReflect(forward, 0, up, forward);
11888                                         VectorNormalize(forward);
11889                                         CrossProduct(up, forward, newright);
11890                                         VectorNormalize(newright);
11891                                         // rotate the quad around the up axis vector, this is made
11892                                         // especially easy by the fact we know the quad is flat,
11893                                         // so we only have to subtract the center position and
11894                                         // measure distance along the right vector, and then
11895                                         // multiply that by the newright vector and add back the
11896                                         // center position
11897                                         // we also need to subtract the old position to undo the
11898                                         // displacement from the center, which we do with a
11899                                         // DotProduct, the subtraction/addition of center is also
11900                                         // optimized into DotProducts here
11901                                         l = DotProduct(right, center);
11902                                         for (i = 0;i < 4;i++)
11903                                         {
11904                                                 v1 = rsurface.batchvertex3f + 3*(j+i);
11905                                                 f = DotProduct(right, v1) - l;
11906                                                 VectorMAMAM(1, v1, -f, right, f, newright, rsurface.array_batchvertex3f + 3*(j+i));
11907                                         }
11908                                 }
11909                         }
11910                         rsurface.batchvertex3f = rsurface.array_batchvertex3f;
11911                         rsurface.batchvertex3f_vertexbuffer = NULL;
11912                         rsurface.batchvertex3f_bufferoffset = 0;
11913                         if(batchneed & (BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR)) // otherwise these can stay NULL
11914                         {
11915                                 Mod_BuildNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchnormal3f, true);
11916                                 rsurface.batchnormal3f = rsurface.array_batchnormal3f;
11917                                 rsurface.batchnormal3f_vertexbuffer = NULL;
11918                                 rsurface.batchnormal3f_bufferoffset = 0;
11919                         }
11920                         if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL
11921                         {
11922                                 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);
11923                                 rsurface.batchsvector3f = rsurface.array_batchsvector3f;
11924                                 rsurface.batchsvector3f_vertexbuffer = NULL;
11925                                 rsurface.batchsvector3f_bufferoffset = 0;
11926                                 rsurface.batchtvector3f = rsurface.array_batchtvector3f;
11927                                 rsurface.batchtvector3f_vertexbuffer = NULL;
11928                                 rsurface.batchtvector3f_bufferoffset = 0;
11929                         }
11930                         break;
11931                 case Q3DEFORM_NORMAL:
11932                         // deform the normals to make reflections wavey
11933                         for (j = 0;j < rsurface.batchnumvertices;j++)
11934                         {
11935                                 float vertex[3];
11936                                 float *normal = rsurface.array_batchnormal3f + 3*j;
11937                                 VectorScale(rsurface.batchvertex3f + 3*j, 0.98f, vertex);
11938                                 normal[0] = rsurface.batchnormal3f[j*3+0] + deform->parms[0] * noise4f(      vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
11939                                 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]);
11940                                 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]);
11941                                 VectorNormalize(normal);
11942                         }
11943                         rsurface.batchnormal3f = rsurface.array_batchnormal3f;
11944                         rsurface.batchnormal3f_vertexbuffer = NULL;
11945                         rsurface.batchnormal3f_bufferoffset = 0;
11946                         if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL
11947                         {
11948                                 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);
11949                                 rsurface.batchsvector3f = rsurface.array_batchsvector3f;
11950                                 rsurface.batchsvector3f_vertexbuffer = NULL;
11951                                 rsurface.batchsvector3f_bufferoffset = 0;
11952                                 rsurface.batchtvector3f = rsurface.array_batchtvector3f;
11953                                 rsurface.batchtvector3f_vertexbuffer = NULL;
11954                                 rsurface.batchtvector3f_bufferoffset = 0;
11955                         }
11956                         break;
11957                 case Q3DEFORM_WAVE:
11958                         // deform vertex array to make wavey water and flags and such
11959                         waveparms[0] = deform->waveparms[0];
11960                         waveparms[1] = deform->waveparms[1];
11961                         waveparms[2] = deform->waveparms[2];
11962                         waveparms[3] = deform->waveparms[3];
11963                         if(!R_TestQ3WaveFunc(deform->wavefunc, waveparms))
11964                                 break; // if wavefunc is a nop, don't make a dynamic vertex array
11965                         // this is how a divisor of vertex influence on deformation
11966                         animpos = deform->parms[0] ? 1.0f / deform->parms[0] : 100.0f;
11967                         scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
11968                         for (j = 0;j < rsurface.batchnumvertices;j++)
11969                         {
11970                                 // if the wavefunc depends on time, evaluate it per-vertex
11971                                 if (waveparms[3])
11972                                 {
11973                                         waveparms[2] = deform->waveparms[2] + (rsurface.batchvertex3f[j*3+0] + rsurface.batchvertex3f[j*3+1] + rsurface.batchvertex3f[j*3+2]) * animpos;
11974                                         scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
11975                                 }
11976                                 VectorMA(rsurface.batchvertex3f + 3*j, scale, rsurface.batchnormal3f + 3*j, rsurface.array_batchvertex3f + 3*j);
11977                         }
11978                         // if we get here, BATCHNEED_ARRAY_NORMAL is in batchneed, so no need to check
11979                         Mod_BuildNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchnormal3f, true);
11980                         rsurface.batchvertex3f = rsurface.array_batchvertex3f;
11981                         rsurface.batchvertex3f_vertexbuffer = NULL;
11982                         rsurface.batchvertex3f_bufferoffset = 0;
11983                         rsurface.batchnormal3f = rsurface.array_batchnormal3f;
11984                         rsurface.batchnormal3f_vertexbuffer = NULL;
11985                         rsurface.batchnormal3f_bufferoffset = 0;
11986                         if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL
11987                         {
11988                                 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);
11989                                 rsurface.batchsvector3f = rsurface.array_batchsvector3f;
11990                                 rsurface.batchsvector3f_vertexbuffer = NULL;
11991                                 rsurface.batchsvector3f_bufferoffset = 0;
11992                                 rsurface.batchtvector3f = rsurface.array_batchtvector3f;
11993                                 rsurface.batchtvector3f_vertexbuffer = NULL;
11994                                 rsurface.batchtvector3f_bufferoffset = 0;
11995                         }
11996                         break;
11997                 case Q3DEFORM_BULGE:
11998                         // deform vertex array to make the surface have moving bulges
11999                         for (j = 0;j < rsurface.batchnumvertices;j++)
12000                         {
12001                                 scale = sin(rsurface.batchtexcoordtexture2f[j*2+0] * deform->parms[0] + r_refdef.scene.time * deform->parms[2]) * deform->parms[1];
12002                                 VectorMA(rsurface.batchvertex3f + 3*j, scale, rsurface.batchnormal3f + 3*j, rsurface.array_batchvertex3f + 3*j);
12003                         }
12004                         // if we get here, BATCHNEED_ARRAY_NORMAL is in batchneed, so no need to check
12005                         Mod_BuildNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchnormal3f, true);
12006                         rsurface.batchvertex3f = rsurface.array_batchvertex3f;
12007                         rsurface.batchvertex3f_vertexbuffer = NULL;
12008                         rsurface.batchvertex3f_bufferoffset = 0;
12009                         rsurface.batchnormal3f = rsurface.array_batchnormal3f;
12010                         rsurface.batchnormal3f_vertexbuffer = NULL;
12011                         rsurface.batchnormal3f_bufferoffset = 0;
12012                         if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL
12013                         {
12014                                 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);
12015                                 rsurface.batchsvector3f = rsurface.array_batchsvector3f;
12016                                 rsurface.batchsvector3f_vertexbuffer = NULL;
12017                                 rsurface.batchsvector3f_bufferoffset = 0;
12018                                 rsurface.batchtvector3f = rsurface.array_batchtvector3f;
12019                                 rsurface.batchtvector3f_vertexbuffer = NULL;
12020                                 rsurface.batchtvector3f_bufferoffset = 0;
12021                         }
12022                         break;
12023                 case Q3DEFORM_MOVE:
12024                         // deform vertex array
12025                         if(!R_TestQ3WaveFunc(deform->wavefunc, deform->waveparms))
12026                                 break; // if wavefunc is a nop, don't make a dynamic vertex array
12027                         scale = R_EvaluateQ3WaveFunc(deform->wavefunc, deform->waveparms);
12028                         VectorScale(deform->parms, scale, waveparms);
12029                         for (j = 0;j < rsurface.batchnumvertices;j++)
12030                                 VectorAdd(rsurface.batchvertex3f + 3*j, waveparms, rsurface.array_batchvertex3f + 3*j);
12031                         rsurface.batchvertex3f = rsurface.array_batchvertex3f;
12032                         rsurface.batchvertex3f_vertexbuffer = NULL;
12033                         rsurface.batchvertex3f_bufferoffset = 0;
12034                         break;
12035                 }
12036         }
12037
12038         // generate texcoords based on the chosen texcoord source
12039         switch(rsurface.texture->tcgen.tcgen)
12040         {
12041         default:
12042         case Q3TCGEN_TEXTURE:
12043                 break;
12044         case Q3TCGEN_LIGHTMAP:
12045                 if (rsurface.batchtexcoordlightmap2f)
12046                         memcpy(rsurface.array_batchtexcoordlightmap2f, rsurface.batchtexcoordtexture2f, rsurface.batchnumvertices * sizeof(float[2]));
12047                 rsurface.batchtexcoordtexture2f = rsurface.array_batchtexcoordtexture2f;
12048                 rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
12049                 rsurface.batchtexcoordtexture2f_bufferoffset = 0;
12050                 break;
12051         case Q3TCGEN_VECTOR:
12052                 for (j = 0;j < rsurface.batchnumvertices;j++)
12053                 {
12054                         rsurface.array_batchtexcoordtexture2f[j*2+0] = DotProduct(rsurface.batchvertex3f + 3*j, rsurface.texture->tcgen.parms);
12055                         rsurface.array_batchtexcoordtexture2f[j*2+1] = DotProduct(rsurface.batchvertex3f + 3*j, rsurface.texture->tcgen.parms + 3);
12056                 }
12057                 rsurface.batchtexcoordtexture2f = rsurface.array_batchtexcoordtexture2f;
12058                 rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
12059                 rsurface.batchtexcoordtexture2f_bufferoffset = 0;
12060                 break;
12061         case Q3TCGEN_ENVIRONMENT:
12062                 // make environment reflections using a spheremap
12063                 for (j = 0;j < rsurface.batchnumvertices;j++)
12064                 {
12065                         // identical to Q3A's method, but executed in worldspace so
12066                         // carried models can be shiny too
12067
12068                         float viewer[3], d, reflected[3], worldreflected[3];
12069
12070                         VectorSubtract(rsurface.localvieworigin, rsurface.batchvertex3f + 3*j, viewer);
12071                         // VectorNormalize(viewer);
12072
12073                         d = DotProduct(rsurface.batchnormal3f + 3*j, viewer);
12074
12075                         reflected[0] = rsurface.batchnormal3f[j*3+0]*2*d - viewer[0];
12076                         reflected[1] = rsurface.batchnormal3f[j*3+1]*2*d - viewer[1];
12077                         reflected[2] = rsurface.batchnormal3f[j*3+2]*2*d - viewer[2];
12078                         // note: this is proportinal to viewer, so we can normalize later
12079
12080                         Matrix4x4_Transform3x3(&rsurface.matrix, reflected, worldreflected);
12081                         VectorNormalize(worldreflected);
12082
12083                         // note: this sphere map only uses world x and z!
12084                         // so positive and negative y will LOOK THE SAME.
12085                         rsurface.array_batchtexcoordtexture2f[j*2+0] = 0.5 + 0.5 * worldreflected[1];
12086                         rsurface.array_batchtexcoordtexture2f[j*2+1] = 0.5 - 0.5 * worldreflected[2];
12087                 }
12088                 rsurface.batchtexcoordtexture2f = rsurface.array_batchtexcoordtexture2f;
12089                 rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
12090                 rsurface.batchtexcoordtexture2f_bufferoffset = 0;
12091                 break;
12092         }
12093         // the only tcmod that needs software vertex processing is turbulent, so
12094         // check for it here and apply the changes if needed
12095         // and we only support that as the first one
12096         // (handling a mixture of turbulent and other tcmods would be problematic
12097         //  without punting it entirely to a software path)
12098         if (rsurface.texture->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
12099         {
12100                 amplitude = rsurface.texture->tcmods[0].parms[1];
12101                 animpos = rsurface.texture->tcmods[0].parms[2] + r_refdef.scene.time * rsurface.texture->tcmods[0].parms[3];
12102                 for (j = 0;j < rsurface.batchnumvertices;j++)
12103                 {
12104                         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);
12105                         rsurface.array_batchtexcoordtexture2f[j*2+1] += amplitude * sin(((rsurface.batchvertex3f[j*3+1]                                ) * 1.0 / 1024.0f + animpos) * M_PI * 2);
12106                 }
12107                 rsurface.batchtexcoordtexture2f = rsurface.array_batchtexcoordtexture2f;
12108                 rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
12109                 rsurface.batchtexcoordtexture2f_bufferoffset = 0;
12110         }
12111
12112         if (needsupdate & batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP))
12113         {
12114                 // convert the modified arrays to vertex structs
12115                 rsurface.batchvertexmesh = rsurface.array_batchvertexmesh;
12116                 rsurface.batchvertexmeshbuffer = NULL;
12117                 if (batchneed & BATCHNEED_VERTEXMESH_VERTEX)
12118                         for (j = 0, vertexmesh = rsurface.array_batchvertexmesh;j < rsurface.batchnumvertices;j++, vertexmesh++)
12119                                 VectorCopy(rsurface.batchvertex3f + 3*j, vertexmesh->vertex3f);
12120                 if (batchneed & BATCHNEED_VERTEXMESH_NORMAL)
12121                         for (j = 0, vertexmesh = rsurface.array_batchvertexmesh;j < rsurface.batchnumvertices;j++, vertexmesh++)
12122                                 VectorCopy(rsurface.batchnormal3f + 3*j, vertexmesh->normal3f);
12123                 if (batchneed & BATCHNEED_VERTEXMESH_VECTOR)
12124                 {
12125                         for (j = 0, vertexmesh = rsurface.array_batchvertexmesh;j < rsurface.batchnumvertices;j++, vertexmesh++)
12126                         {
12127                                 VectorCopy(rsurface.batchsvector3f + 3*j, vertexmesh->svector3f);
12128                                 VectorCopy(rsurface.batchtvector3f + 3*j, vertexmesh->tvector3f);
12129                         }
12130                 }
12131                 if ((batchneed & BATCHNEED_VERTEXMESH_VERTEXCOLOR) && rsurface.batchlightmapcolor4f)
12132                         for (j = 0, vertexmesh = rsurface.array_batchvertexmesh;j < rsurface.batchnumvertices;j++, vertexmesh++)
12133                                 Vector4Scale(rsurface.batchlightmapcolor4f + 4*j, 255.0f, vertexmesh->color4ub);
12134                 if (batchneed & BATCHNEED_VERTEXMESH_TEXCOORD)
12135                         for (j = 0, vertexmesh = rsurface.array_batchvertexmesh;j < rsurface.batchnumvertices;j++, vertexmesh++)
12136                                 Vector2Copy(rsurface.batchtexcoordtexture2f + 2*j, vertexmesh->texcoordtexture2f);
12137                 if ((batchneed & BATCHNEED_VERTEXMESH_LIGHTMAP) && rsurface.batchtexcoordlightmap2f)
12138                         for (j = 0, vertexmesh = rsurface.array_batchvertexmesh;j < rsurface.batchnumvertices;j++, vertexmesh++)
12139                                 Vector2Copy(rsurface.batchtexcoordlightmap2f + 2*j, vertexmesh->texcoordlightmap2f);
12140         }
12141
12142         if (needsupdate & batchneed & BATCHNEED_VERTEXPOSITION)
12143         {
12144                 // convert the modified arrays to vertex structs
12145                 rsurface.batchvertexposition = rsurface.array_batchvertexposition;
12146                 rsurface.batchvertexpositionbuffer = NULL;
12147                 if (sizeof(r_vertexposition_t) == sizeof(float[3]))
12148                         memcpy(rsurface.array_batchvertexposition, rsurface.batchvertex3f, rsurface.batchnumvertices * sizeof(r_vertexposition_t));
12149                 else
12150                         for (j = 0, vertexposition = rsurface.array_batchvertexposition;j < rsurface.batchnumvertices;j++, vertexposition++)
12151                                 VectorCopy(rsurface.batchvertex3f + 3*j, vertexposition->vertex3f);
12152         }
12153 }
12154
12155 void RSurf_DrawBatch(void)
12156 {
12157         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);
12158 }
12159
12160 static int RSurf_FindWaterPlaneForSurface(const msurface_t *surface)
12161 {
12162         // pick the closest matching water plane
12163         int planeindex, vertexindex, bestplaneindex = -1;
12164         float d, bestd;
12165         vec3_t vert;
12166         const float *v;
12167         r_waterstate_waterplane_t *p;
12168         bestd = 0;
12169         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
12170         {
12171                 if(p->camera_entity != rsurface.texture->camera_entity)
12172                         continue;
12173                 d = 0;
12174                 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX, 1, &surface);
12175                 for (vertexindex = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3;vertexindex < rsurface.batchnumvertices;vertexindex++, v += 3)
12176                 {
12177                         Matrix4x4_Transform(&rsurface.matrix, v, vert);
12178                         d += fabs(PlaneDiff(vert, &p->plane));
12179                 }
12180                 if (bestd > d || bestplaneindex < 0)
12181                 {
12182                         bestd = d;
12183                         bestplaneindex = planeindex;
12184                 }
12185         }
12186         return bestplaneindex;
12187 }
12188
12189 static void RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray(void)
12190 {
12191         int i;
12192         for (i = 0;i < rsurface.batchnumvertices;i++)
12193                 Vector4Set(rsurface.array_passcolor4f + 4*i, 0.5f, 0.5f, 0.5f, 1.0f);
12194         rsurface.passcolor4f = rsurface.array_passcolor4f;
12195         rsurface.passcolor4f_vertexbuffer = 0;
12196         rsurface.passcolor4f_bufferoffset = 0;
12197 }
12198
12199 static void RSurf_DrawBatch_GL11_ApplyFog(void)
12200 {
12201         int i;
12202         float f;
12203         const float *v;
12204         const float *c;
12205         float *c2;
12206         if (rsurface.passcolor4f)
12207         {
12208                 // generate color arrays
12209                 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)
12210                 {
12211                         f = RSurf_FogVertex(v);
12212                         c2[0] = c[0] * f;
12213                         c2[1] = c[1] * f;
12214                         c2[2] = c[2] * f;
12215                         c2[3] = c[3];
12216                 }
12217         }
12218         else
12219         {
12220                 for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, c2 = rsurface.array_passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, c2 += 4)
12221                 {
12222                         f = RSurf_FogVertex(v);
12223                         c2[0] = f;
12224                         c2[1] = f;
12225                         c2[2] = f;
12226                         c2[3] = 1;
12227                 }
12228         }
12229         rsurface.passcolor4f = rsurface.array_passcolor4f;
12230         rsurface.passcolor4f_vertexbuffer = 0;
12231         rsurface.passcolor4f_bufferoffset = 0;
12232 }
12233
12234 static void RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors(void)
12235 {
12236         int i;
12237         float f;
12238         const float *v;
12239         const float *c;
12240         float *c2;
12241         if (!rsurface.passcolor4f)
12242                 return;
12243         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)
12244         {
12245                 f = RSurf_FogVertex(v);
12246                 c2[0] = c[0] * f + r_refdef.fogcolor[0] * (1 - f);
12247                 c2[1] = c[1] * f + r_refdef.fogcolor[1] * (1 - f);
12248                 c2[2] = c[2] * f + r_refdef.fogcolor[2] * (1 - f);
12249                 c2[3] = c[3];
12250         }
12251         rsurface.passcolor4f = rsurface.array_passcolor4f;
12252         rsurface.passcolor4f_vertexbuffer = 0;
12253         rsurface.passcolor4f_bufferoffset = 0;
12254 }
12255
12256 static void RSurf_DrawBatch_GL11_ApplyColor(float r, float g, float b, float a)
12257 {
12258         int i;
12259         const float *c;
12260         float *c2;
12261         if (!rsurface.passcolor4f)
12262                 return;
12263         for (i = 0, c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4, c2 = rsurface.array_passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, c += 4, c2 += 4)
12264         {
12265                 c2[0] = c[0] * r;
12266                 c2[1] = c[1] * g;
12267                 c2[2] = c[2] * b;
12268                 c2[3] = c[3] * a;
12269         }
12270         rsurface.passcolor4f = rsurface.array_passcolor4f;
12271         rsurface.passcolor4f_vertexbuffer = 0;
12272         rsurface.passcolor4f_bufferoffset = 0;
12273 }
12274
12275 static void RSurf_DrawBatch_GL11_ApplyAmbient(void)
12276 {
12277         int i;
12278         const float *c;
12279         float *c2;
12280         if (!rsurface.passcolor4f)
12281                 return;
12282         for (i = 0, c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4, c2 = rsurface.array_passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, c += 4, c2 += 4)
12283         {
12284                 c2[0] = c[0] + r_refdef.scene.ambient;
12285                 c2[1] = c[1] + r_refdef.scene.ambient;
12286                 c2[2] = c[2] + r_refdef.scene.ambient;
12287                 c2[3] = c[3];
12288         }
12289         rsurface.passcolor4f = rsurface.array_passcolor4f;
12290         rsurface.passcolor4f_vertexbuffer = 0;
12291         rsurface.passcolor4f_bufferoffset = 0;
12292 }
12293
12294 static void RSurf_DrawBatch_GL11_Lightmap(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
12295 {
12296         // TODO: optimize
12297         rsurface.passcolor4f = NULL;
12298         rsurface.passcolor4f_vertexbuffer = 0;
12299         rsurface.passcolor4f_bufferoffset = 0;
12300         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog();
12301         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
12302         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
12303         GL_Color(r, g, b, a);
12304         R_Mesh_TexBind(0, rsurface.lightmaptexture);
12305         RSurf_DrawBatch();
12306 }
12307
12308 static void RSurf_DrawBatch_GL11_Unlit(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
12309 {
12310         // TODO: optimize applyfog && applycolor case
12311         // just apply fog if necessary, and tint the fog color array if necessary
12312         rsurface.passcolor4f = NULL;
12313         rsurface.passcolor4f_vertexbuffer = 0;
12314         rsurface.passcolor4f_bufferoffset = 0;
12315         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog();
12316         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
12317         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
12318         GL_Color(r, g, b, a);
12319         RSurf_DrawBatch();
12320 }
12321
12322 static void RSurf_DrawBatch_GL11_VertexColor(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
12323 {
12324         // TODO: optimize
12325         rsurface.passcolor4f = rsurface.batchlightmapcolor4f;
12326         rsurface.passcolor4f_vertexbuffer = rsurface.batchlightmapcolor4f_vertexbuffer;
12327         rsurface.passcolor4f_bufferoffset = rsurface.batchlightmapcolor4f_bufferoffset;
12328         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog();
12329         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
12330         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
12331         GL_Color(r, g, b, a);
12332         RSurf_DrawBatch();
12333 }
12334
12335 static void RSurf_DrawBatch_GL11_ClampColor(void)
12336 {
12337         int i;
12338         const float *c1;
12339         float *c2;
12340         if (!rsurface.passcolor4f)
12341                 return;
12342         for (i = 0, c1 = rsurface.passcolor4f + 4*rsurface.batchfirstvertex, c2 = rsurface.array_passcolor4f + 4*rsurface.batchfirstvertex;i < rsurface.batchnumvertices;i++, c1 += 4, c2 += 4)
12343         {
12344                 c2[0] = bound(0.0f, c1[0], 1.0f);
12345                 c2[1] = bound(0.0f, c1[1], 1.0f);
12346                 c2[2] = bound(0.0f, c1[2], 1.0f);
12347                 c2[3] = bound(0.0f, c1[3], 1.0f);
12348         }
12349 }
12350
12351 static void RSurf_DrawBatch_GL11_ApplyFakeLight(void)
12352 {
12353         int i;
12354         float f;
12355         const float *v;
12356         const float *n;
12357         float *c;
12358         //vec3_t eyedir;
12359
12360         // fake shading
12361         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)
12362         {
12363                 f = -DotProduct(r_refdef.view.forward, n);
12364                 f = max(0, f);
12365                 f = f * 0.85 + 0.15; // work around so stuff won't get black
12366                 f *= r_refdef.lightmapintensity;
12367                 Vector4Set(c, f, f, f, 1);
12368         }
12369
12370         rsurface.passcolor4f = rsurface.array_passcolor4f;
12371         rsurface.passcolor4f_vertexbuffer = 0;
12372         rsurface.passcolor4f_bufferoffset = 0;
12373 }
12374
12375 static void RSurf_DrawBatch_GL11_FakeLight(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
12376 {
12377         RSurf_DrawBatch_GL11_ApplyFakeLight();
12378         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog();
12379         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
12380         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
12381         GL_Color(r, g, b, a);
12382         RSurf_DrawBatch();
12383 }
12384
12385 static void RSurf_DrawBatch_GL11_ApplyVertexShade(float *r, float *g, float *b, float *a, qboolean *applycolor)
12386 {
12387         int i;
12388         float f;
12389         float alpha;
12390         const float *v;
12391         const float *n;
12392         float *c;
12393         vec3_t ambientcolor;
12394         vec3_t diffusecolor;
12395         vec3_t lightdir;
12396         // TODO: optimize
12397         // model lighting
12398         VectorCopy(rsurface.modellight_lightdir, lightdir);
12399         f = 0.5f * r_refdef.lightmapintensity;
12400         ambientcolor[0] = rsurface.modellight_ambient[0] * *r * f;
12401         ambientcolor[1] = rsurface.modellight_ambient[1] * *g * f;
12402         ambientcolor[2] = rsurface.modellight_ambient[2] * *b * f;
12403         diffusecolor[0] = rsurface.modellight_diffuse[0] * *r * f;
12404         diffusecolor[1] = rsurface.modellight_diffuse[1] * *g * f;
12405         diffusecolor[2] = rsurface.modellight_diffuse[2] * *b * f;
12406         alpha = *a;
12407         if (VectorLength2(diffusecolor) > 0)
12408         {
12409                 // q3-style directional shading
12410                 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)
12411                 {
12412                         if ((f = DotProduct(n, lightdir)) > 0)
12413                                 VectorMA(ambientcolor, f, diffusecolor, c);
12414                         else
12415                                 VectorCopy(ambientcolor, c);
12416                         c[3] = alpha;
12417                 }
12418                 *r = 1;
12419                 *g = 1;
12420                 *b = 1;
12421                 *a = 1;
12422                 rsurface.passcolor4f = rsurface.array_passcolor4f;
12423                 rsurface.passcolor4f_vertexbuffer = 0;
12424                 rsurface.passcolor4f_bufferoffset = 0;
12425                 *applycolor = false;
12426         }
12427         else
12428         {
12429                 *r = ambientcolor[0];
12430                 *g = ambientcolor[1];
12431                 *b = ambientcolor[2];
12432                 rsurface.passcolor4f = NULL;
12433                 rsurface.passcolor4f_vertexbuffer = 0;
12434                 rsurface.passcolor4f_bufferoffset = 0;
12435         }
12436 }
12437
12438 static void RSurf_DrawBatch_GL11_VertexShade(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
12439 {
12440         RSurf_DrawBatch_GL11_ApplyVertexShade(&r, &g, &b, &a, &applycolor);
12441         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog();
12442         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
12443         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
12444         GL_Color(r, g, b, a);
12445         RSurf_DrawBatch();
12446 }
12447
12448 static void RSurf_DrawBatch_GL11_MakeFogColor(float r, float g, float b, float a)
12449 {
12450         int i;
12451         float f;
12452         const float *v;
12453         float *c;
12454         for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, c = rsurface.array_passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, c += 4)
12455         {
12456                 f = 1 - RSurf_FogVertex(v);
12457                 c[0] = r;
12458                 c[1] = g;
12459                 c[2] = b;
12460                 c[3] = f * a;
12461         }
12462 }
12463
12464 void RSurf_SetupDepthAndCulling(void)
12465 {
12466         // submodels are biased to avoid z-fighting with world surfaces that they
12467         // may be exactly overlapping (avoids z-fighting artifacts on certain
12468         // doors and things in Quake maps)
12469         GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
12470         GL_PolygonOffset(rsurface.basepolygonfactor + rsurface.texture->biaspolygonfactor, rsurface.basepolygonoffset + rsurface.texture->biaspolygonoffset);
12471         GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
12472         GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_refdef.view.cullface_back);
12473 }
12474
12475 static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, const msurface_t **texturesurfacelist)
12476 {
12477         // transparent sky would be ridiculous
12478         if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
12479                 return;
12480         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
12481         skyrenderlater = true;
12482         RSurf_SetupDepthAndCulling();
12483         GL_DepthMask(true);
12484         // LordHavoc: HalfLife maps have freaky skypolys so don't use
12485         // skymasking on them, and Quake3 never did sky masking (unlike
12486         // software Quake and software Quake2), so disable the sky masking
12487         // in Quake3 maps as it causes problems with q3map2 sky tricks,
12488         // and skymasking also looks very bad when noclipping outside the
12489         // level, so don't use it then either.
12490         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_refdef.viewcache.world_novis)
12491         {
12492                 R_Mesh_ResetTextureState();
12493                 if (skyrendermasked)
12494                 {
12495                         R_SetupShader_DepthOrShadow();
12496                         // depth-only (masking)
12497                         GL_ColorMask(0,0,0,0);
12498                         // just to make sure that braindead drivers don't draw
12499                         // anything despite that colormask...
12500                         GL_BlendFunc(GL_ZERO, GL_ONE);
12501                         RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXPOSITION | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12502                         R_Mesh_PrepareVertices_Position(rsurface.batchnumvertices, rsurface.batchvertexposition, rsurface.batchvertexpositionbuffer);
12503                 }
12504                 else
12505                 {
12506                         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
12507                         // fog sky
12508                         GL_BlendFunc(GL_ONE, GL_ZERO);
12509                         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12510                         GL_Color(r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2], 1);
12511                         R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, NULL, NULL);
12512                 }
12513                 RSurf_DrawBatch();
12514                 if (skyrendermasked)
12515                         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
12516         }
12517         R_Mesh_ResetTextureState();
12518         GL_Color(1, 1, 1, 1);
12519 }
12520
12521 extern rtexture_t *r_shadow_prepasslightingdiffusetexture;
12522 extern rtexture_t *r_shadow_prepasslightingspeculartexture;
12523 static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
12524 {
12525         if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA)))
12526                 return;
12527         if (prepass)
12528         {
12529                 // render screenspace normalmap to texture
12530                 GL_DepthMask(true);
12531                 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_DEFERREDGEOMETRY, texturenumsurfaces, texturesurfacelist, NULL);
12532                 RSurf_DrawBatch();
12533                 return;
12534         }
12535
12536         // bind lightmap texture
12537
12538         // water/refraction/reflection/camera surfaces have to be handled specially
12539         if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_CAMERA | MATERIALFLAG_REFLECTION)) && !r_waterstate.renderingscene)
12540         {
12541                 int start, end, startplaneindex;
12542                 for (start = 0;start < texturenumsurfaces;start = end)
12543                 {
12544                         startplaneindex = RSurf_FindWaterPlaneForSurface(texturesurfacelist[start]);
12545                         for (end = start + 1;end < texturenumsurfaces && startplaneindex == RSurf_FindWaterPlaneForSurface(texturesurfacelist[end]);end++)
12546                                 ;
12547                         // now that we have a batch using the same planeindex, render it
12548                         if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_CAMERA)) && !r_waterstate.renderingscene)
12549                         {
12550                                 // render water or distortion background
12551                                 GL_DepthMask(true);
12552                                 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));
12553                                 RSurf_DrawBatch();
12554                                 // blend surface on top
12555                                 GL_DepthMask(false);
12556                                 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE, end-start, texturesurfacelist + start, NULL);
12557                                 RSurf_DrawBatch();
12558                         }
12559                         else if ((rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION) && !r_waterstate.renderingscene)
12560                         {
12561                                 // render surface with reflection texture as input
12562                                 GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED));
12563                                 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));
12564                                 RSurf_DrawBatch();
12565                         }
12566                 }
12567                 return;
12568         }
12569
12570         // render surface batch normally
12571         GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED));
12572         R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE, texturenumsurfaces, texturesurfacelist, NULL);
12573         RSurf_DrawBatch();
12574 }
12575
12576 static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
12577 {
12578         // OpenGL 1.3 path - anything not completely ancient
12579         qboolean applycolor;
12580         qboolean applyfog;
12581         int layerindex;
12582         const texturelayer_t *layer;
12583         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);
12584         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
12585
12586         for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
12587         {
12588                 vec4_t layercolor;
12589                 int layertexrgbscale;
12590                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
12591                 {
12592                         if (layerindex == 0)
12593                                 GL_AlphaTest(true);
12594                         else
12595                         {
12596                                 GL_AlphaTest(false);
12597                                 GL_DepthFunc(GL_EQUAL);
12598                         }
12599                 }
12600                 GL_DepthMask(layer->depthmask && writedepth);
12601                 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
12602                 if (layer->color[0] > 2 || layer->color[1] > 2 || layer->color[2] > 2)
12603                 {
12604                         layertexrgbscale = 4;
12605                         VectorScale(layer->color, 0.25f, layercolor);
12606                 }
12607                 else if (layer->color[0] > 1 || layer->color[1] > 1 || layer->color[2] > 1)
12608                 {
12609                         layertexrgbscale = 2;
12610                         VectorScale(layer->color, 0.5f, layercolor);
12611                 }
12612                 else
12613                 {
12614                         layertexrgbscale = 1;
12615                         VectorScale(layer->color, 1.0f, layercolor);
12616                 }
12617                 layercolor[3] = layer->color[3];
12618                 applycolor = layercolor[0] != 1 || layercolor[1] != 1 || layercolor[2] != 1 || layercolor[3] != 1;
12619                 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, 0, 0);
12620                 applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
12621                 switch (layer->type)
12622                 {
12623                 case TEXTURELAYERTYPE_LITTEXTURE:
12624                         // single-pass lightmapped texture with 2x rgbscale
12625                         R_Mesh_TexBind(0, r_texture_white);
12626                         R_Mesh_TexMatrix(0, NULL);
12627                         R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
12628                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordlightmap2f_vertexbuffer, rsurface.batchtexcoordlightmap2f_bufferoffset);
12629                         R_Mesh_TexBind(1, layer->texture);
12630                         R_Mesh_TexMatrix(1, &layer->texmatrix);
12631                         R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
12632                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
12633                         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
12634                                 RSurf_DrawBatch_GL11_VertexShade(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
12635                         else if (FAKELIGHT_ENABLED)
12636                                 RSurf_DrawBatch_GL11_FakeLight(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
12637                         else if (rsurface.uselightmaptexture)
12638                                 RSurf_DrawBatch_GL11_Lightmap(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
12639                         else
12640                                 RSurf_DrawBatch_GL11_VertexColor(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
12641                         break;
12642                 case TEXTURELAYERTYPE_TEXTURE:
12643                         // singletexture unlit texture with transparency support
12644                         R_Mesh_TexBind(0, layer->texture);
12645                         R_Mesh_TexMatrix(0, &layer->texmatrix);
12646                         R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
12647                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
12648                         R_Mesh_TexBind(1, 0);
12649                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, 0, 0);
12650                         RSurf_DrawBatch_GL11_Unlit(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
12651                         break;
12652                 case TEXTURELAYERTYPE_FOG:
12653                         // singletexture fogging
12654                         if (layer->texture)
12655                         {
12656                                 R_Mesh_TexBind(0, layer->texture);
12657                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
12658                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
12659                                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
12660                         }
12661                         else
12662                         {
12663                                 R_Mesh_TexBind(0, 0);
12664                                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, 0, 0);
12665                         }
12666                         R_Mesh_TexBind(1, 0);
12667                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, 0, 0);
12668                         // generate a color array for the fog pass
12669                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.array_passcolor4f, 0, 0);
12670                         RSurf_DrawBatch_GL11_MakeFogColor(layercolor[0], layercolor[1], layercolor[2], layercolor[3]);
12671                         RSurf_DrawBatch();
12672                         break;
12673                 default:
12674                         Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
12675                 }
12676         }
12677         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
12678         {
12679                 GL_DepthFunc(GL_LEQUAL);
12680                 GL_AlphaTest(false);
12681         }
12682 }
12683
12684 static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
12685 {
12686         // OpenGL 1.1 - crusty old voodoo path
12687         qboolean applyfog;
12688         int layerindex;
12689         const texturelayer_t *layer;
12690         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);
12691         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
12692
12693         for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
12694         {
12695                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
12696                 {
12697                         if (layerindex == 0)
12698                                 GL_AlphaTest(true);
12699                         else
12700                         {
12701                                 GL_AlphaTest(false);
12702                                 GL_DepthFunc(GL_EQUAL);
12703                         }
12704                 }
12705                 GL_DepthMask(layer->depthmask && writedepth);
12706                 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
12707                 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, 0, 0);
12708                 applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
12709                 switch (layer->type)
12710                 {
12711                 case TEXTURELAYERTYPE_LITTEXTURE:
12712                         if (layer->blendfunc1 == GL_ONE && layer->blendfunc2 == GL_ZERO)
12713                         {
12714                                 // two-pass lit texture with 2x rgbscale
12715                                 // first the lightmap pass
12716                                 R_Mesh_TexBind(0, r_texture_white);
12717                                 R_Mesh_TexMatrix(0, NULL);
12718                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
12719                                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordlightmap2f_vertexbuffer, rsurface.batchtexcoordlightmap2f_bufferoffset);
12720                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
12721                                         RSurf_DrawBatch_GL11_VertexShade(1, 1, 1, 1, false, false);
12722                                 else if (FAKELIGHT_ENABLED)
12723                                         RSurf_DrawBatch_GL11_FakeLight(1, 1, 1, 1, false, false);
12724                                 else if (rsurface.uselightmaptexture)
12725                                         RSurf_DrawBatch_GL11_Lightmap(1, 1, 1, 1, false, false);
12726                                 else
12727                                         RSurf_DrawBatch_GL11_VertexColor(1, 1, 1, 1, false, false);
12728                                 // then apply the texture to it
12729                                 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
12730                                 R_Mesh_TexBind(0, layer->texture);
12731                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
12732                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
12733                                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
12734                                 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);
12735                         }
12736                         else
12737                         {
12738                                 // single pass vertex-lighting-only texture with 1x rgbscale and transparency support
12739                                 R_Mesh_TexBind(0, layer->texture);
12740                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
12741                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
12742                                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
12743                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
12744                                         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);
12745                                 else
12746                                         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);
12747                         }
12748                         break;
12749                 case TEXTURELAYERTYPE_TEXTURE:
12750                         // singletexture unlit texture with transparency support
12751                         R_Mesh_TexBind(0, layer->texture);
12752                         R_Mesh_TexMatrix(0, &layer->texmatrix);
12753                         R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
12754                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
12755                         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);
12756                         break;
12757                 case TEXTURELAYERTYPE_FOG:
12758                         // singletexture fogging
12759                         if (layer->texture)
12760                         {
12761                                 R_Mesh_TexBind(0, layer->texture);
12762                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
12763                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
12764                                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
12765                         }
12766                         else
12767                         {
12768                                 R_Mesh_TexBind(0, 0);
12769                                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, 0, 0);
12770                         }
12771                         // generate a color array for the fog pass
12772                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.array_passcolor4f, 0, 0);
12773                         RSurf_DrawBatch_GL11_MakeFogColor(layer->color[0], layer->color[1], layer->color[2], layer->color[3]);
12774                         RSurf_DrawBatch();
12775                         break;
12776                 default:
12777                         Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
12778                 }
12779         }
12780         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
12781         {
12782                 GL_DepthFunc(GL_LEQUAL);
12783                 GL_AlphaTest(false);
12784         }
12785 }
12786
12787 static void R_DrawTextureSurfaceList_ShowSurfaces(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
12788 {
12789         int vi;
12790         int j;
12791         r_vertexgeneric_t *batchvertex;
12792         float c[4];
12793
12794         GL_AlphaTest(false);
12795         R_Mesh_ResetTextureState();
12796         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
12797
12798         if(rsurface.texture && rsurface.texture->currentskinframe)
12799         {
12800                 memcpy(c, rsurface.texture->currentskinframe->avgcolor, sizeof(c));
12801                 c[3] *= rsurface.texture->currentalpha;
12802         }
12803         else
12804         {
12805                 c[0] = 1;
12806                 c[1] = 0;
12807                 c[2] = 1;
12808                 c[3] = 1;
12809         }
12810
12811         if (rsurface.texture->pantstexture || rsurface.texture->shirttexture)
12812         {
12813                 c[0] = 0.5 * (rsurface.colormap_pantscolor[0] * 0.3 + rsurface.colormap_shirtcolor[0] * 0.7);
12814                 c[1] = 0.5 * (rsurface.colormap_pantscolor[1] * 0.3 + rsurface.colormap_shirtcolor[1] * 0.7);
12815                 c[2] = 0.5 * (rsurface.colormap_pantscolor[2] * 0.3 + rsurface.colormap_shirtcolor[2] * 0.7);
12816         }
12817
12818         // brighten it up (as texture value 127 means "unlit")
12819         c[0] *= 2 * r_refdef.view.colorscale;
12820         c[1] *= 2 * r_refdef.view.colorscale;
12821         c[2] *= 2 * r_refdef.view.colorscale;
12822
12823         if(rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERALPHA)
12824                 c[3] *= r_wateralpha.value;
12825
12826         if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHA && c[3] != 1)
12827         {
12828                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
12829                 GL_DepthMask(false);
12830         }
12831         else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
12832         {
12833                 GL_BlendFunc(GL_ONE, GL_ONE);
12834                 GL_DepthMask(false);
12835         }
12836         else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
12837         {
12838                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // can't do alpha test without texture, so let's blend instead
12839                 GL_DepthMask(false);
12840         }
12841         else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
12842         {
12843                 GL_BlendFunc(rsurface.texture->customblendfunc[0], rsurface.texture->customblendfunc[1]);
12844                 GL_DepthMask(false);
12845         }
12846         else
12847         {
12848                 GL_BlendFunc(GL_ONE, GL_ZERO);
12849                 GL_DepthMask(writedepth);
12850         }
12851
12852         if (r_showsurfaces.integer == 3)
12853         {
12854                 rsurface.passcolor4f = NULL;
12855
12856                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
12857                 {
12858                         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12859
12860                         rsurface.passcolor4f = NULL;
12861                         rsurface.passcolor4f_vertexbuffer = 0;
12862                         rsurface.passcolor4f_bufferoffset = 0;
12863                 }
12864                 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
12865                 {
12866                         qboolean applycolor = true;
12867                         float one = 1.0;
12868
12869                         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12870
12871                         r_refdef.lightmapintensity = 1;
12872                         RSurf_DrawBatch_GL11_ApplyVertexShade(&one, &one, &one, &one, &applycolor);
12873                         r_refdef.lightmapintensity = 0; // we're in showsurfaces, after all
12874                 }
12875                 else if (FAKELIGHT_ENABLED)
12876                 {
12877                         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12878
12879                         r_refdef.lightmapintensity = r_fakelight_intensity.value;
12880                         RSurf_DrawBatch_GL11_ApplyFakeLight();
12881                         r_refdef.lightmapintensity = 0; // we're in showsurfaces, after all
12882                 }
12883                 else
12884                 {
12885                         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_VERTEXCOLOR | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12886
12887                         rsurface.passcolor4f = rsurface.batchlightmapcolor4f;
12888                         rsurface.passcolor4f_vertexbuffer = rsurface.batchlightmapcolor4f_vertexbuffer;
12889                         rsurface.passcolor4f_bufferoffset = rsurface.batchlightmapcolor4f_bufferoffset;
12890                 }
12891
12892                 if(!rsurface.passcolor4f)
12893                         RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray();
12894
12895                 RSurf_DrawBatch_GL11_ApplyAmbient();
12896                 RSurf_DrawBatch_GL11_ApplyColor(c[0], c[1], c[2], c[3]);
12897                 if(r_refdef.fogenabled)
12898                         RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors();
12899                 RSurf_DrawBatch_GL11_ClampColor();
12900
12901                 R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, rsurface.passcolor4f, NULL);
12902                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
12903                 RSurf_DrawBatch();
12904         }
12905         else if (!r_refdef.view.showdebug)
12906         {
12907                 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12908                 batchvertex = R_Mesh_PrepareVertices_Generic_Lock(rsurface.batchnumvertices);
12909                 for (j = 0, vi = rsurface.batchfirstvertex;j < rsurface.batchnumvertices;j++, vi++)
12910                 {
12911                         VectorCopy(rsurface.batchvertex3f + 3*vi, batchvertex[vi].vertex3f);
12912                         Vector4Set(batchvertex[vi].color4ub, 0, 0, 0, 255);
12913                 }
12914                 R_Mesh_PrepareVertices_Generic_Unlock();
12915                 RSurf_DrawBatch();
12916         }
12917         else if (r_showsurfaces.integer == 4)
12918         {
12919                 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12920                 batchvertex = R_Mesh_PrepareVertices_Generic_Lock(rsurface.batchnumvertices);
12921                 for (j = 0, vi = rsurface.batchfirstvertex;j < rsurface.batchnumvertices;j++, vi++)
12922                 {
12923                         unsigned char c = vi << 3;
12924                         VectorCopy(rsurface.batchvertex3f + 3*vi, batchvertex[vi].vertex3f);
12925                         Vector4Set(batchvertex[vi].color4ub, c, c, c, 255);
12926                 }
12927                 R_Mesh_PrepareVertices_Generic_Unlock();
12928                 RSurf_DrawBatch();
12929         }
12930         else if (r_showsurfaces.integer == 2)
12931         {
12932                 const int *e;
12933                 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12934                 batchvertex = R_Mesh_PrepareVertices_Generic_Lock(3*rsurface.batchnumtriangles);
12935                 for (j = 0, e = rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle;j < rsurface.batchnumtriangles;j++, e += 3)
12936                 {
12937                         unsigned char c = (j + rsurface.batchfirsttriangle) << 3;
12938                         VectorCopy(rsurface.batchvertex3f + 3*e[0], batchvertex[j*3+0].vertex3f);
12939                         VectorCopy(rsurface.batchvertex3f + 3*e[1], batchvertex[j*3+1].vertex3f);
12940                         VectorCopy(rsurface.batchvertex3f + 3*e[2], batchvertex[j*3+2].vertex3f);
12941                         Vector4Set(batchvertex[j*3+0].color4ub, c, c, c, 255);
12942                         Vector4Set(batchvertex[j*3+1].color4ub, c, c, c, 255);
12943                         Vector4Set(batchvertex[j*3+2].color4ub, c, c, c, 255);
12944                 }
12945                 R_Mesh_PrepareVertices_Generic_Unlock();
12946                 R_Mesh_Draw(0, rsurface.batchnumtriangles*3, 0, rsurface.batchnumtriangles, NULL, NULL, 0, NULL, NULL, 0);
12947         }
12948         else
12949         {
12950                 int texturesurfaceindex;
12951                 int k;
12952                 const msurface_t *surface;
12953                 unsigned char surfacecolor4ub[4];
12954                 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12955                 batchvertex = R_Mesh_PrepareVertices_Generic_Lock(rsurface.batchfirstvertex + rsurface.batchnumvertices);
12956                 vi = 0;
12957                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
12958                 {
12959                         surface = texturesurfacelist[texturesurfaceindex];
12960                         k = (int)(((size_t)surface) / sizeof(msurface_t));
12961                         Vector4Set(surfacecolor4ub, (k & 0xF) << 4, (k & 0xF0), (k & 0xF00) >> 4, 255);
12962                         for (j = 0;j < surface->num_vertices;j++)
12963                         {
12964                                 VectorCopy(rsurface.batchvertex3f + 3*vi, batchvertex[vi].vertex3f);
12965                                 Vector4Copy(surfacecolor4ub, batchvertex[vi].color4ub);
12966                                 vi++;
12967                         }
12968                 }
12969                 R_Mesh_PrepareVertices_Generic_Unlock();
12970                 RSurf_DrawBatch();
12971         }
12972 }
12973
12974 static void R_DrawWorldTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
12975 {
12976         CHECKGLERROR
12977         RSurf_SetupDepthAndCulling();
12978         if (r_showsurfaces.integer)
12979         {
12980                 R_DrawTextureSurfaceList_ShowSurfaces(texturenumsurfaces, texturesurfacelist, writedepth);
12981                 return;
12982         }
12983         switch (vid.renderpath)
12984         {
12985         case RENDERPATH_GL20:
12986         case RENDERPATH_CGGL:
12987         case RENDERPATH_D3D9:
12988         case RENDERPATH_D3D10:
12989         case RENDERPATH_D3D11:
12990                 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
12991                 break;
12992         case RENDERPATH_GL13:
12993                 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
12994                 break;
12995         case RENDERPATH_GL11:
12996                 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
12997                 break;
12998         }
12999         CHECKGLERROR
13000 }
13001
13002 static void R_DrawModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
13003 {
13004         CHECKGLERROR
13005         RSurf_SetupDepthAndCulling();
13006         if (r_showsurfaces.integer)
13007         {
13008                 R_DrawTextureSurfaceList_ShowSurfaces(texturenumsurfaces, texturesurfacelist, writedepth);
13009                 return;
13010         }
13011         switch (vid.renderpath)
13012         {
13013         case RENDERPATH_GL20:
13014         case RENDERPATH_CGGL:
13015         case RENDERPATH_D3D9:
13016         case RENDERPATH_D3D10:
13017         case RENDERPATH_D3D11:
13018                 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
13019                 break;
13020         case RENDERPATH_GL13:
13021                 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
13022                 break;
13023         case RENDERPATH_GL11:
13024                 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
13025                 break;
13026         }
13027         CHECKGLERROR
13028 }
13029
13030 static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
13031 {
13032         int i, j;
13033         int texturenumsurfaces, endsurface;
13034         texture_t *texture;
13035         const msurface_t *surface;
13036 #define MAXBATCH_TRANSPARENTSURFACES 256
13037         const msurface_t *texturesurfacelist[MAXBATCH_TRANSPARENTSURFACES];
13038
13039         // if the model is static it doesn't matter what value we give for
13040         // wantnormals and wanttangents, so this logic uses only rules applicable
13041         // to a model, knowing that they are meaningless otherwise
13042         if (ent == r_refdef.scene.worldentity)
13043                 RSurf_ActiveWorldEntity();
13044         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
13045                 RSurf_ActiveModelEntity(ent, false, false, false);
13046         else
13047         {
13048                 switch (vid.renderpath)
13049                 {
13050                 case RENDERPATH_GL20:
13051                 case RENDERPATH_CGGL:
13052                 case RENDERPATH_D3D9:
13053                 case RENDERPATH_D3D10:
13054                 case RENDERPATH_D3D11:
13055                         RSurf_ActiveModelEntity(ent, true, true, false);
13056                         break;
13057                 case RENDERPATH_GL13:
13058                 case RENDERPATH_GL11:
13059                         RSurf_ActiveModelEntity(ent, true, false, false);
13060                         break;
13061                 }
13062         }
13063
13064         if (r_transparentdepthmasking.integer)
13065         {
13066                 qboolean setup = false;
13067                 for (i = 0;i < numsurfaces;i = j)
13068                 {
13069                         j = i + 1;
13070                         surface = rsurface.modelsurfaces + surfacelist[i];
13071                         texture = surface->texture;
13072                         rsurface.texture = R_GetCurrentTexture(texture);
13073                         rsurface.lightmaptexture = NULL;
13074                         rsurface.deluxemaptexture = NULL;
13075                         rsurface.uselightmaptexture = false;
13076                         // scan ahead until we find a different texture
13077                         endsurface = min(i + 1024, numsurfaces);
13078                         texturenumsurfaces = 0;
13079                         texturesurfacelist[texturenumsurfaces++] = surface;
13080                         for (;j < endsurface;j++)
13081                         {
13082                                 surface = rsurface.modelsurfaces + surfacelist[j];
13083                                 if (texture != surface->texture)
13084                                         break;
13085                                 texturesurfacelist[texturenumsurfaces++] = surface;
13086                         }
13087                         if (!(rsurface.texture->currentmaterialflags & MATERIALFLAG_TRANSDEPTH))
13088                                 continue;
13089                         // render the range of surfaces as depth
13090                         if (!setup)
13091                         {
13092                                 setup = true;
13093                                 GL_ColorMask(0,0,0,0);
13094                                 GL_Color(1,1,1,1);
13095                                 GL_DepthTest(true);
13096                                 GL_BlendFunc(GL_ONE, GL_ZERO);
13097                                 GL_DepthMask(true);
13098                                 GL_AlphaTest(false);
13099                                 R_Mesh_ResetTextureState();
13100                                 R_SetupShader_DepthOrShadow();
13101                         }
13102                         RSurf_SetupDepthAndCulling();
13103                         RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXPOSITION, texturenumsurfaces, texturesurfacelist);
13104                         R_Mesh_PrepareVertices_Position(rsurface.batchnumvertices, rsurface.batchvertexposition, rsurface.batchvertexpositionbuffer);
13105                         RSurf_DrawBatch();
13106                 }
13107                 if (setup)
13108                         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
13109         }
13110
13111         for (i = 0;i < numsurfaces;i = j)
13112         {
13113                 j = i + 1;
13114                 surface = rsurface.modelsurfaces + surfacelist[i];
13115                 texture = surface->texture;
13116                 rsurface.texture = R_GetCurrentTexture(texture);
13117                 // scan ahead until we find a different texture
13118                 endsurface = min(i + MAXBATCH_TRANSPARENTSURFACES, numsurfaces);
13119                 texturenumsurfaces = 0;
13120                 texturesurfacelist[texturenumsurfaces++] = surface;
13121                 if(FAKELIGHT_ENABLED)
13122                 {
13123                         rsurface.lightmaptexture = NULL;
13124                         rsurface.deluxemaptexture = NULL;
13125                         rsurface.uselightmaptexture = false;
13126                         for (;j < endsurface;j++)
13127                         {
13128                                 surface = rsurface.modelsurfaces + surfacelist[j];
13129                                 if (texture != surface->texture)
13130                                         break;
13131                                 texturesurfacelist[texturenumsurfaces++] = surface;
13132                         }
13133                 }
13134                 else
13135                 {
13136                         rsurface.lightmaptexture = surface->lightmaptexture;
13137                         rsurface.deluxemaptexture = surface->deluxemaptexture;
13138                         rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
13139                         for (;j < endsurface;j++)
13140                         {
13141                                 surface = rsurface.modelsurfaces + surfacelist[j];
13142                                 if (texture != surface->texture || rsurface.lightmaptexture != surface->lightmaptexture)
13143                                         break;
13144                                 texturesurfacelist[texturenumsurfaces++] = surface;
13145                         }
13146                 }
13147                 // render the range of surfaces
13148                 if (ent == r_refdef.scene.worldentity)
13149                         R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false, false);
13150                 else
13151                         R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false, false);
13152         }
13153         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
13154         GL_AlphaTest(false);
13155 }
13156
13157 static void R_ProcessTransparentTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, const entity_render_t *queueentity)
13158 {
13159         // transparent surfaces get pushed off into the transparent queue
13160         int surfacelistindex;
13161         const msurface_t *surface;
13162         vec3_t tempcenter, center;
13163         for (surfacelistindex = 0;surfacelistindex < texturenumsurfaces;surfacelistindex++)
13164         {
13165                 surface = texturesurfacelist[surfacelistindex];
13166                 tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f;
13167                 tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f;
13168                 tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f;
13169                 Matrix4x4_Transform(&rsurface.matrix, tempcenter, center);
13170                 if (queueentity->transparent_offset) // transparent offset
13171                 {
13172                         center[0] += r_refdef.view.forward[0]*queueentity->transparent_offset;
13173                         center[1] += r_refdef.view.forward[1]*queueentity->transparent_offset;
13174                         center[2] += r_refdef.view.forward[2]*queueentity->transparent_offset;
13175                 }
13176                 R_MeshQueue_AddTransparent(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_refdef.view.origin : center, R_DrawSurface_TransparentCallback, queueentity, surface - rsurface.modelsurfaces, rsurface.rtlight);
13177         }
13178 }
13179
13180 static void R_DrawTextureSurfaceList_DepthOnly(int texturenumsurfaces, const msurface_t **texturesurfacelist)
13181 {
13182         if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
13183                 return;
13184         if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)))
13185                 return;
13186         RSurf_SetupDepthAndCulling();
13187         RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXPOSITION, texturenumsurfaces, texturesurfacelist);
13188         R_Mesh_PrepareVertices_Position(rsurface.batchnumvertices, rsurface.batchvertexposition, rsurface.batchvertexpositionbuffer);
13189         RSurf_DrawBatch();
13190 }
13191
13192 static void R_ProcessWorldTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, qboolean prepass)
13193 {
13194         const entity_render_t *queueentity = r_refdef.scene.worldentity;
13195         CHECKGLERROR
13196         if (depthonly)
13197                 R_DrawTextureSurfaceList_DepthOnly(texturenumsurfaces, texturesurfacelist);
13198         else if (prepass)
13199         {
13200                 if (!rsurface.texture->currentnumlayers)
13201                         return;
13202                 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
13203                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
13204                 else
13205                         R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
13206         }
13207         else if ((rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY) && !r_showsurfaces.integer)
13208                 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
13209         else if (!rsurface.texture->currentnumlayers)
13210                 return;
13211         else if (((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) || (r_showsurfaces.integer == 3 && (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST))) && queueentity)
13212         {
13213                 // in the deferred case, transparent surfaces were queued during prepass
13214                 if (!r_shadow_usingdeferredprepass)
13215                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
13216         }
13217         else
13218         {
13219                 // the alphatest check is to make sure we write depth for anything we skipped on the depth-only pass earlier
13220                 R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST), prepass);
13221         }
13222         CHECKGLERROR
13223 }
13224
13225 void R_QueueWorldSurfaceList(int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass)
13226 {
13227         int i, j;
13228         texture_t *texture;
13229         // break the surface list down into batches by texture and use of lightmapping
13230         for (i = 0;i < numsurfaces;i = j)
13231         {
13232                 j = i + 1;
13233                 // texture is the base texture pointer, rsurface.texture is the
13234                 // current frame/skin the texture is directing us to use (for example
13235                 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
13236                 // use skin 1 instead)
13237                 texture = surfacelist[i]->texture;
13238                 rsurface.texture = R_GetCurrentTexture(texture);
13239                 if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW))
13240                 {
13241                         // if this texture is not the kind we want, skip ahead to the next one
13242                         for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
13243                                 ;
13244                         continue;
13245                 }
13246                 if(FAKELIGHT_ENABLED || depthonly || prepass)
13247                 {
13248                         rsurface.lightmaptexture = NULL;
13249                         rsurface.deluxemaptexture = NULL;
13250                         rsurface.uselightmaptexture = false;
13251                         // simply scan ahead until we find a different texture or lightmap state
13252                         for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
13253                                 ;
13254                 }
13255                 else
13256                 {
13257                         rsurface.lightmaptexture = surfacelist[i]->lightmaptexture;
13258                         rsurface.deluxemaptexture = surfacelist[i]->deluxemaptexture;
13259                         rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL;
13260                         // simply scan ahead until we find a different texture or lightmap state
13261                         for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.lightmaptexture == surfacelist[j]->lightmaptexture;j++)
13262                                 ;
13263                 }
13264                 // render the range of surfaces
13265                 R_ProcessWorldTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, prepass);
13266         }
13267 }
13268
13269 static void R_ProcessModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, const entity_render_t *queueentity, qboolean prepass)
13270 {
13271         CHECKGLERROR
13272         if (depthonly)
13273                 R_DrawTextureSurfaceList_DepthOnly(texturenumsurfaces, texturesurfacelist);
13274         else if (prepass)
13275         {
13276                 if (!rsurface.texture->currentnumlayers)
13277                         return;
13278                 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
13279                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
13280                 else
13281                         R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
13282         }
13283         else if ((rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY) && !r_showsurfaces.integer)
13284                 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
13285         else if (!rsurface.texture->currentnumlayers)
13286                 return;
13287         else if (((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) || (r_showsurfaces.integer == 3 && (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST))) && queueentity)
13288         {
13289                 // in the deferred case, transparent surfaces were queued during prepass
13290                 if (!r_shadow_usingdeferredprepass)
13291                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
13292         }
13293         else
13294         {
13295                 // the alphatest check is to make sure we write depth for anything we skipped on the depth-only pass earlier
13296                 R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST), prepass);
13297         }
13298         CHECKGLERROR
13299 }
13300
13301 void R_QueueModelSurfaceList(entity_render_t *ent, int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass)
13302 {
13303         int i, j;
13304         texture_t *texture;
13305         // break the surface list down into batches by texture and use of lightmapping
13306         for (i = 0;i < numsurfaces;i = j)
13307         {
13308                 j = i + 1;
13309                 // texture is the base texture pointer, rsurface.texture is the
13310                 // current frame/skin the texture is directing us to use (for example
13311                 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
13312                 // use skin 1 instead)
13313                 texture = surfacelist[i]->texture;
13314                 rsurface.texture = R_GetCurrentTexture(texture);
13315                 if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW))
13316                 {
13317                         // if this texture is not the kind we want, skip ahead to the next one
13318                         for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
13319                                 ;
13320                         continue;
13321                 }
13322                 if(FAKELIGHT_ENABLED || depthonly || prepass)
13323                 {
13324                         rsurface.lightmaptexture = NULL;
13325                         rsurface.deluxemaptexture = NULL;
13326                         rsurface.uselightmaptexture = false;
13327                         // simply scan ahead until we find a different texture or lightmap state
13328                         for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
13329                                 ;
13330                 }
13331                 else
13332                 {
13333                         rsurface.lightmaptexture = surfacelist[i]->lightmaptexture;
13334                         rsurface.deluxemaptexture = surfacelist[i]->deluxemaptexture;
13335                         rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL;
13336                         // simply scan ahead until we find a different texture or lightmap state
13337                         for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.lightmaptexture == surfacelist[j]->lightmaptexture;j++)
13338                                 ;
13339                 }
13340                 // render the range of surfaces
13341                 R_ProcessModelTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, ent, prepass);
13342         }
13343 }
13344
13345 float locboxvertex3f[6*4*3] =
13346 {
13347         1,0,1, 1,0,0, 1,1,0, 1,1,1,
13348         0,1,1, 0,1,0, 0,0,0, 0,0,1,
13349         1,1,1, 1,1,0, 0,1,0, 0,1,1,
13350         0,0,1, 0,0,0, 1,0,0, 1,0,1,
13351         0,0,1, 1,0,1, 1,1,1, 0,1,1,
13352         1,0,0, 0,0,0, 0,1,0, 1,1,0
13353 };
13354
13355 unsigned short locboxelements[6*2*3] =
13356 {
13357          0, 1, 2, 0, 2, 3,
13358          4, 5, 6, 4, 6, 7,
13359          8, 9,10, 8,10,11,
13360         12,13,14, 12,14,15,
13361         16,17,18, 16,18,19,
13362         20,21,22, 20,22,23
13363 };
13364
13365 void R_DrawLoc_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
13366 {
13367         int i, j;
13368         cl_locnode_t *loc = (cl_locnode_t *)ent;
13369         vec3_t mins, size;
13370         float vertex3f[6*4*3];
13371         CHECKGLERROR
13372         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
13373         GL_DepthMask(false);
13374         GL_DepthRange(0, 1);
13375         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
13376         GL_DepthTest(true);
13377         GL_CullFace(GL_NONE);
13378         R_EntityMatrix(&identitymatrix);
13379
13380         R_Mesh_ResetTextureState();
13381
13382         i = surfacelist[0];
13383         GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f) * r_refdef.view.colorscale,
13384                          ((i & 0x0038) >> 3) * (1.0f / 7.0f) * r_refdef.view.colorscale,
13385                          ((i & 0x01C0) >> 6) * (1.0f / 7.0f) * r_refdef.view.colorscale,
13386                         surfacelist[0] < 0 ? 0.5f : 0.125f);
13387
13388         if (VectorCompare(loc->mins, loc->maxs))
13389         {
13390                 VectorSet(size, 2, 2, 2);
13391                 VectorMA(loc->mins, -0.5f, size, mins);
13392         }
13393         else
13394         {
13395                 VectorCopy(loc->mins, mins);
13396                 VectorSubtract(loc->maxs, loc->mins, size);
13397         }
13398
13399         for (i = 0;i < 6*4*3;)
13400                 for (j = 0;j < 3;j++, i++)
13401                         vertex3f[i] = mins[j] + size[j] * locboxvertex3f[i];
13402
13403         R_Mesh_PrepareVertices_Generic_Arrays(6*4, vertex3f, NULL, NULL);
13404         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
13405         R_Mesh_Draw(0, 6*4, 0, 6*2, NULL, NULL, 0, locboxelements, NULL, 0);
13406 }
13407
13408 void R_DrawLocs(void)
13409 {
13410         int index;
13411         cl_locnode_t *loc, *nearestloc;
13412         vec3_t center;
13413         nearestloc = CL_Locs_FindNearest(cl.movement_origin);
13414         for (loc = cl.locnodes, index = 0;loc;loc = loc->next, index++)
13415         {
13416                 VectorLerp(loc->mins, 0.5f, loc->maxs, center);
13417                 R_MeshQueue_AddTransparent(center, R_DrawLoc_Callback, (entity_render_t *)loc, loc == nearestloc ? -1 : index, NULL);
13418         }
13419 }
13420
13421 void R_DecalSystem_Reset(decalsystem_t *decalsystem)
13422 {
13423         if (decalsystem->decals)
13424                 Mem_Free(decalsystem->decals);
13425         memset(decalsystem, 0, sizeof(*decalsystem));
13426 }
13427
13428 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)
13429 {
13430         tridecal_t *decal;
13431         tridecal_t *decals;
13432         int i;
13433
13434         // expand or initialize the system
13435         if (decalsystem->maxdecals <= decalsystem->numdecals)
13436         {
13437                 decalsystem_t old = *decalsystem;
13438                 qboolean useshortelements;
13439                 decalsystem->maxdecals = max(16, decalsystem->maxdecals * 2);
13440                 useshortelements = decalsystem->maxdecals * 3 <= 65536;
13441                 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)));
13442                 decalsystem->color4f = (float *)(decalsystem->decals + decalsystem->maxdecals);
13443                 decalsystem->texcoord2f = (float *)(decalsystem->color4f + decalsystem->maxdecals*12);
13444                 decalsystem->vertex3f = (float *)(decalsystem->texcoord2f + decalsystem->maxdecals*6);
13445                 decalsystem->element3i = (int *)(decalsystem->vertex3f + decalsystem->maxdecals*9);
13446                 decalsystem->element3s = (useshortelements ? ((unsigned short *)(decalsystem->element3i + decalsystem->maxdecals*3)) : NULL);
13447                 if (decalsystem->numdecals)
13448                         memcpy(decalsystem->decals, old.decals, decalsystem->numdecals * sizeof(tridecal_t));
13449                 if (old.decals)
13450                         Mem_Free(old.decals);
13451                 for (i = 0;i < decalsystem->maxdecals*3;i++)
13452                         decalsystem->element3i[i] = i;
13453                 if (useshortelements)
13454                         for (i = 0;i < decalsystem->maxdecals*3;i++)
13455                                 decalsystem->element3s[i] = i;
13456         }
13457
13458         // grab a decal and search for another free slot for the next one
13459         decals = decalsystem->decals;
13460         decal = decalsystem->decals + (i = decalsystem->freedecal++);
13461         for (i = decalsystem->freedecal;i < decalsystem->numdecals && decals[i].color4ub[0][3];i++)
13462                 ;
13463         decalsystem->freedecal = i;
13464         if (decalsystem->numdecals <= i)
13465                 decalsystem->numdecals = i + 1;
13466
13467         // initialize the decal
13468         decal->lived = 0;
13469         decal->triangleindex = triangleindex;
13470         decal->surfaceindex = surfaceindex;
13471         decal->decalsequence = decalsequence;
13472         decal->color4ub[0][0] = (unsigned char)(c0[0]*255.0f);
13473         decal->color4ub[0][1] = (unsigned char)(c0[1]*255.0f);
13474         decal->color4ub[0][2] = (unsigned char)(c0[2]*255.0f);
13475         decal->color4ub[0][3] = 255;
13476         decal->color4ub[1][0] = (unsigned char)(c1[0]*255.0f);
13477         decal->color4ub[1][1] = (unsigned char)(c1[1]*255.0f);
13478         decal->color4ub[1][2] = (unsigned char)(c1[2]*255.0f);
13479         decal->color4ub[1][3] = 255;
13480         decal->color4ub[2][0] = (unsigned char)(c2[0]*255.0f);
13481         decal->color4ub[2][1] = (unsigned char)(c2[1]*255.0f);
13482         decal->color4ub[2][2] = (unsigned char)(c2[2]*255.0f);
13483         decal->color4ub[2][3] = 255;
13484         decal->vertex3f[0][0] = v0[0];
13485         decal->vertex3f[0][1] = v0[1];
13486         decal->vertex3f[0][2] = v0[2];
13487         decal->vertex3f[1][0] = v1[0];
13488         decal->vertex3f[1][1] = v1[1];
13489         decal->vertex3f[1][2] = v1[2];
13490         decal->vertex3f[2][0] = v2[0];
13491         decal->vertex3f[2][1] = v2[1];
13492         decal->vertex3f[2][2] = v2[2];
13493         decal->texcoord2f[0][0] = t0[0];
13494         decal->texcoord2f[0][1] = t0[1];
13495         decal->texcoord2f[1][0] = t1[0];
13496         decal->texcoord2f[1][1] = t1[1];
13497         decal->texcoord2f[2][0] = t2[0];
13498         decal->texcoord2f[2][1] = t2[1];
13499 }
13500
13501 extern cvar_t cl_decals_bias;
13502 extern cvar_t cl_decals_models;
13503 extern cvar_t cl_decals_newsystem_intensitymultiplier;
13504 // baseparms, parms, temps
13505 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)
13506 {
13507         int cornerindex;
13508         int index;
13509         float v[9][3];
13510         const float *vertex3f;
13511         int numpoints;
13512         float points[2][9][3];
13513         float temp[3];
13514         float tc[9][2];
13515         float f;
13516         float c[9][4];
13517         const int *e;
13518
13519         e = rsurface.modelelement3i + 3*triangleindex;
13520
13521         vertex3f = rsurface.modelvertex3f;
13522
13523         for (cornerindex = 0;cornerindex < 3;cornerindex++)
13524         {
13525                 index = 3*e[cornerindex];
13526                 VectorCopy(vertex3f + index, v[cornerindex]);
13527         }
13528         // cull backfaces
13529         //TriangleNormal(v[0], v[1], v[2], normal);
13530         //if (DotProduct(normal, localnormal) < 0.0f)
13531         //      continue;
13532         // clip by each of the box planes formed from the projection matrix
13533         // if anything survives, we emit the decal
13534         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]);
13535         if (numpoints < 3)
13536                 return;
13537         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]);
13538         if (numpoints < 3)
13539                 return;
13540         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]);
13541         if (numpoints < 3)
13542                 return;
13543         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]);
13544         if (numpoints < 3)
13545                 return;
13546         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]);
13547         if (numpoints < 3)
13548                 return;
13549         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]);
13550         if (numpoints < 3)
13551                 return;
13552         // some part of the triangle survived, so we have to accept it...
13553         if (dynamic)
13554         {
13555                 // dynamic always uses the original triangle
13556                 numpoints = 3;
13557                 for (cornerindex = 0;cornerindex < 3;cornerindex++)
13558                 {
13559                         index = 3*e[cornerindex];
13560                         VectorCopy(vertex3f + index, v[cornerindex]);
13561                 }
13562         }
13563         for (cornerindex = 0;cornerindex < numpoints;cornerindex++)
13564         {
13565                 // convert vertex positions to texcoords
13566                 Matrix4x4_Transform(projection, v[cornerindex], temp);
13567                 tc[cornerindex][0] = (temp[1]+1.0f)*0.5f * (s2-s1) + s1;
13568                 tc[cornerindex][1] = (temp[2]+1.0f)*0.5f * (t2-t1) + t1;
13569                 // calculate distance fade from the projection origin
13570                 f = a * (1.0f-fabs(temp[0])) * cl_decals_newsystem_intensitymultiplier.value;
13571                 f = bound(0.0f, f, 1.0f);
13572                 c[cornerindex][0] = r * f;
13573                 c[cornerindex][1] = g * f;
13574                 c[cornerindex][2] = b * f;
13575                 c[cornerindex][3] = 1.0f;
13576                 //VectorMA(v[cornerindex], cl_decals_bias.value, localnormal, v[cornerindex]);
13577         }
13578         if (dynamic)
13579                 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);
13580         else
13581                 for (cornerindex = 0;cornerindex < numpoints-2;cornerindex++)
13582                         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);
13583 }
13584 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)
13585 {
13586         matrix4x4_t projection;
13587         decalsystem_t *decalsystem;
13588         qboolean dynamic;
13589         dp_model_t *model;
13590         const msurface_t *surface;
13591         const msurface_t *surfaces;
13592         const int *surfacelist;
13593         const texture_t *texture;
13594         int numtriangles;
13595         int numsurfacelist;
13596         int surfacelistindex;
13597         int surfaceindex;
13598         int triangleindex;
13599         float localorigin[3];
13600         float localnormal[3];
13601         float localmins[3];
13602         float localmaxs[3];
13603         float localsize;
13604         //float normal[3];
13605         float planes[6][4];
13606         float angles[3];
13607         bih_t *bih;
13608         int bih_triangles_count;
13609         int bih_triangles[256];
13610         int bih_surfaces[256];
13611
13612         decalsystem = &ent->decalsystem;
13613         model = ent->model;
13614         if (!model || !ent->allowdecals || ent->alpha < 1 || (ent->flags & (RENDER_ADDITIVE | RENDER_NODEPTHTEST)))
13615         {
13616                 R_DecalSystem_Reset(&ent->decalsystem);
13617                 return;
13618         }
13619
13620         if (!model->brush.data_leafs && !cl_decals_models.integer)
13621         {
13622                 if (decalsystem->model)
13623                         R_DecalSystem_Reset(decalsystem);
13624                 return;
13625         }
13626
13627         if (decalsystem->model != model)
13628                 R_DecalSystem_Reset(decalsystem);
13629         decalsystem->model = model;
13630
13631         RSurf_ActiveModelEntity(ent, false, false, false);
13632
13633         Matrix4x4_Transform(&rsurface.inversematrix, worldorigin, localorigin);
13634         Matrix4x4_Transform3x3(&rsurface.inversematrix, worldnormal, localnormal);
13635         VectorNormalize(localnormal);
13636         localsize = worldsize*rsurface.inversematrixscale;
13637         localmins[0] = localorigin[0] - localsize;
13638         localmins[1] = localorigin[1] - localsize;
13639         localmins[2] = localorigin[2] - localsize;
13640         localmaxs[0] = localorigin[0] + localsize;
13641         localmaxs[1] = localorigin[1] + localsize;
13642         localmaxs[2] = localorigin[2] + localsize;
13643
13644         //VectorCopy(localnormal, planes[4]);
13645         //VectorVectors(planes[4], planes[2], planes[0]);
13646         AnglesFromVectors(angles, localnormal, NULL, false);
13647         AngleVectors(angles, planes[0], planes[2], planes[4]);
13648         VectorNegate(planes[0], planes[1]);
13649         VectorNegate(planes[2], planes[3]);
13650         VectorNegate(planes[4], planes[5]);
13651         planes[0][3] = DotProduct(planes[0], localorigin) - localsize;
13652         planes[1][3] = DotProduct(planes[1], localorigin) - localsize;
13653         planes[2][3] = DotProduct(planes[2], localorigin) - localsize;
13654         planes[3][3] = DotProduct(planes[3], localorigin) - localsize;
13655         planes[4][3] = DotProduct(planes[4], localorigin) - localsize;
13656         planes[5][3] = DotProduct(planes[5], localorigin) - localsize;
13657
13658 #if 1
13659 // works
13660 {
13661         matrix4x4_t forwardprojection;
13662         Matrix4x4_CreateFromQuakeEntity(&forwardprojection, localorigin[0], localorigin[1], localorigin[2], angles[0], angles[1], angles[2], localsize);
13663         Matrix4x4_Invert_Simple(&projection, &forwardprojection);
13664 }
13665 #else
13666 // broken
13667 {
13668         float projectionvector[4][3];
13669         VectorScale(planes[0], ilocalsize, projectionvector[0]);
13670         VectorScale(planes[2], ilocalsize, projectionvector[1]);
13671         VectorScale(planes[4], ilocalsize, projectionvector[2]);
13672         projectionvector[0][0] = planes[0][0] * ilocalsize;
13673         projectionvector[0][1] = planes[1][0] * ilocalsize;
13674         projectionvector[0][2] = planes[2][0] * ilocalsize;
13675         projectionvector[1][0] = planes[0][1] * ilocalsize;
13676         projectionvector[1][1] = planes[1][1] * ilocalsize;
13677         projectionvector[1][2] = planes[2][1] * ilocalsize;
13678         projectionvector[2][0] = planes[0][2] * ilocalsize;
13679         projectionvector[2][1] = planes[1][2] * ilocalsize;
13680         projectionvector[2][2] = planes[2][2] * ilocalsize;
13681         projectionvector[3][0] = -(localorigin[0]*projectionvector[0][0]+localorigin[1]*projectionvector[1][0]+localorigin[2]*projectionvector[2][0]);
13682         projectionvector[3][1] = -(localorigin[0]*projectionvector[0][1]+localorigin[1]*projectionvector[1][1]+localorigin[2]*projectionvector[2][1]);
13683         projectionvector[3][2] = -(localorigin[0]*projectionvector[0][2]+localorigin[1]*projectionvector[1][2]+localorigin[2]*projectionvector[2][2]);
13684         Matrix4x4_FromVectors(&projection, projectionvector[0], projectionvector[1], projectionvector[2], projectionvector[3]);
13685 }
13686 #endif
13687
13688         dynamic = model->surfmesh.isanimated;
13689         numsurfacelist = model->nummodelsurfaces;
13690         surfacelist = model->sortedmodelsurfaces;
13691         surfaces = model->data_surfaces;
13692
13693         bih = NULL;
13694         bih_triangles_count = -1;
13695         if(!dynamic)
13696         {
13697                 if(model->render_bih.numleafs)
13698                         bih = &model->render_bih;
13699                 else if(model->collision_bih.numleafs)
13700                         bih = &model->collision_bih;
13701         }
13702         if(bih)
13703                 bih_triangles_count = BIH_GetTriangleListForBox(bih, sizeof(bih_triangles) / sizeof(*bih_triangles), bih_triangles, bih_surfaces, localmins, localmaxs);
13704         if(bih_triangles_count == 0)
13705                 return;
13706         if(bih_triangles_count > (int) (sizeof(bih_triangles) / sizeof(*bih_triangles))) // hit too many, likely bad anyway
13707                 return;
13708         if(bih_triangles_count > 0)
13709         {
13710                 for (triangleindex = 0; triangleindex < bih_triangles_count; ++triangleindex)
13711                 {
13712                         surfaceindex = bih_surfaces[triangleindex];
13713                         surface = surfaces + surfaceindex;
13714                         texture = surface->texture;
13715                         if (texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SKY | MATERIALFLAG_SHORTDEPTHRANGE | MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
13716                                 continue;
13717                         if (texture->surfaceflags & Q3SURFACEFLAG_NOMARKS)
13718                                 continue;
13719                         R_DecalSystem_SplatTriangle(decalsystem, r, g, b, a, s1, t1, s2, t2, decalsequence, dynamic, planes, &projection, bih_triangles[triangleindex], surfaceindex);
13720                 }
13721         }
13722         else
13723         {
13724                 for (surfacelistindex = 0;surfacelistindex < numsurfacelist;surfacelistindex++)
13725                 {
13726                         surfaceindex = surfacelist[surfacelistindex];
13727                         surface = surfaces + surfaceindex;
13728                         // check cull box first because it rejects more than any other check
13729                         if (!dynamic && !BoxesOverlap(surface->mins, surface->maxs, localmins, localmaxs))
13730                                 continue;
13731                         // skip transparent surfaces
13732                         texture = surface->texture;
13733                         if (texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SKY | MATERIALFLAG_SHORTDEPTHRANGE | MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
13734                                 continue;
13735                         if (texture->surfaceflags & Q3SURFACEFLAG_NOMARKS)
13736                                 continue;
13737                         numtriangles = surface->num_triangles;
13738                         for (triangleindex = 0; triangleindex < numtriangles; triangleindex++)
13739                                 R_DecalSystem_SplatTriangle(decalsystem, r, g, b, a, s1, t1, s2, t2, decalsequence, dynamic, planes, &projection, triangleindex + surface->num_firsttriangle, surfaceindex);
13740                 }
13741         }
13742 }
13743
13744 // do not call this outside of rendering code - use R_DecalSystem_SplatEntities instead
13745 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)
13746 {
13747         int renderentityindex;
13748         float worldmins[3];
13749         float worldmaxs[3];
13750         entity_render_t *ent;
13751
13752         if (!cl_decals_newsystem.integer)
13753                 return;
13754
13755         worldmins[0] = worldorigin[0] - worldsize;
13756         worldmins[1] = worldorigin[1] - worldsize;
13757         worldmins[2] = worldorigin[2] - worldsize;
13758         worldmaxs[0] = worldorigin[0] + worldsize;
13759         worldmaxs[1] = worldorigin[1] + worldsize;
13760         worldmaxs[2] = worldorigin[2] + worldsize;
13761
13762         R_DecalSystem_SplatEntity(r_refdef.scene.worldentity, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence);
13763
13764         for (renderentityindex = 0;renderentityindex < r_refdef.scene.numentities;renderentityindex++)
13765         {
13766                 ent = r_refdef.scene.entities[renderentityindex];
13767                 if (!BoxesOverlap(ent->mins, ent->maxs, worldmins, worldmaxs))
13768                         continue;
13769
13770                 R_DecalSystem_SplatEntity(ent, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence);
13771         }
13772 }
13773
13774 typedef struct r_decalsystem_splatqueue_s
13775 {
13776         vec3_t worldorigin;
13777         vec3_t worldnormal;
13778         float color[4];
13779         float tcrange[4];
13780         float worldsize;
13781         int decalsequence;
13782 }
13783 r_decalsystem_splatqueue_t;
13784
13785 int r_decalsystem_numqueued = 0;
13786 r_decalsystem_splatqueue_t r_decalsystem_queue[MAX_DECALSYSTEM_QUEUE];
13787
13788 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)
13789 {
13790         r_decalsystem_splatqueue_t *queue;
13791
13792         if (!cl_decals_newsystem.integer || r_decalsystem_numqueued == MAX_DECALSYSTEM_QUEUE)
13793                 return;
13794
13795         queue = &r_decalsystem_queue[r_decalsystem_numqueued++];
13796         VectorCopy(worldorigin, queue->worldorigin);
13797         VectorCopy(worldnormal, queue->worldnormal);
13798         Vector4Set(queue->color, r, g, b, a);
13799         Vector4Set(queue->tcrange, s1, t1, s2, t2);
13800         queue->worldsize = worldsize;
13801         queue->decalsequence = cl.decalsequence++;
13802 }
13803
13804 static void R_DecalSystem_ApplySplatEntitiesQueue(void)
13805 {
13806         int i;
13807         r_decalsystem_splatqueue_t *queue;
13808
13809         for (i = 0, queue = r_decalsystem_queue;i < r_decalsystem_numqueued;i++, queue++)
13810                 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);
13811         r_decalsystem_numqueued = 0;
13812 }
13813
13814 extern cvar_t cl_decals_max;
13815 static void R_DrawModelDecals_FadeEntity(entity_render_t *ent)
13816 {
13817         int i;
13818         decalsystem_t *decalsystem = &ent->decalsystem;
13819         int numdecals;
13820         int killsequence;
13821         tridecal_t *decal;
13822         float frametime;
13823         float lifetime;
13824
13825         if (!decalsystem->numdecals)
13826                 return;
13827
13828         if (r_showsurfaces.integer)
13829                 return;
13830
13831         if (ent->model != decalsystem->model || ent->alpha < 1 || (ent->flags & RENDER_ADDITIVE))
13832         {
13833                 R_DecalSystem_Reset(decalsystem);
13834                 return;
13835         }
13836
13837         killsequence = cl.decalsequence - max(1, cl_decals_max.integer);
13838         lifetime = cl_decals_time.value + cl_decals_fadetime.value;
13839
13840         if (decalsystem->lastupdatetime)
13841                 frametime = (cl.time - decalsystem->lastupdatetime);
13842         else
13843                 frametime = 0;
13844         decalsystem->lastupdatetime = cl.time;
13845         decal = decalsystem->decals;
13846         numdecals = decalsystem->numdecals;
13847
13848         for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++)
13849         {
13850                 if (decal->color4ub[0][3])
13851                 {
13852                         decal->lived += frametime;
13853                         if (killsequence - decal->decalsequence > 0 || decal->lived >= lifetime)
13854                         {
13855                                 memset(decal, 0, sizeof(*decal));
13856                                 if (decalsystem->freedecal > i)
13857                                         decalsystem->freedecal = i;
13858                         }
13859                 }
13860         }
13861         decal = decalsystem->decals;
13862         while (numdecals > 0 && !decal[numdecals-1].color4ub[0][3])
13863                 numdecals--;
13864
13865         // collapse the array by shuffling the tail decals into the gaps
13866         for (;;)
13867         {
13868                 while (decalsystem->freedecal < numdecals && decal[decalsystem->freedecal].color4ub[0][3])
13869                         decalsystem->freedecal++;
13870                 if (decalsystem->freedecal == numdecals)
13871                         break;
13872                 decal[decalsystem->freedecal] = decal[--numdecals];
13873         }
13874
13875         decalsystem->numdecals = numdecals;
13876
13877         if (numdecals <= 0)
13878         {
13879                 // if there are no decals left, reset decalsystem
13880                 R_DecalSystem_Reset(decalsystem);
13881         }
13882 }
13883
13884 extern skinframe_t *decalskinframe;
13885 static void R_DrawModelDecals_Entity(entity_render_t *ent)
13886 {
13887         int i;
13888         decalsystem_t *decalsystem = &ent->decalsystem;
13889         int numdecals;
13890         tridecal_t *decal;
13891         float faderate;
13892         float alpha;
13893         float *v3f;
13894         float *c4f;
13895         float *t2f;
13896         const int *e;
13897         const unsigned char *surfacevisible = ent == r_refdef.scene.worldentity ? r_refdef.viewcache.world_surfacevisible : NULL;
13898         int numtris = 0;
13899
13900         numdecals = decalsystem->numdecals;
13901         if (!numdecals)
13902                 return;
13903
13904         if (r_showsurfaces.integer)
13905                 return;
13906
13907         if (ent->model != decalsystem->model || ent->alpha < 1 || (ent->flags & RENDER_ADDITIVE))
13908         {
13909                 R_DecalSystem_Reset(decalsystem);
13910                 return;
13911         }
13912
13913         // if the model is static it doesn't matter what value we give for
13914         // wantnormals and wanttangents, so this logic uses only rules applicable
13915         // to a model, knowing that they are meaningless otherwise
13916         if (ent == r_refdef.scene.worldentity)
13917                 RSurf_ActiveWorldEntity();
13918         else
13919                 RSurf_ActiveModelEntity(ent, false, false, false);
13920
13921         decalsystem->lastupdatetime = cl.time;
13922         decal = decalsystem->decals;
13923
13924         faderate = 1.0f / max(0.001f, cl_decals_fadetime.value);
13925
13926         // update vertex positions for animated models
13927         v3f = decalsystem->vertex3f;
13928         c4f = decalsystem->color4f;
13929         t2f = decalsystem->texcoord2f;
13930         for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++)
13931         {
13932                 if (!decal->color4ub[0][3])
13933                         continue;
13934
13935                 if (surfacevisible && !surfacevisible[decal->surfaceindex])
13936                         continue;
13937
13938                 // update color values for fading decals
13939                 if (decal->lived >= cl_decals_time.value)
13940                 {
13941                         alpha = 1 - faderate * (decal->lived - cl_decals_time.value);
13942                         alpha *= (1.0f/255.0f);
13943                 }
13944                 else
13945                         alpha = 1.0f/255.0f;
13946
13947                 c4f[ 0] = decal->color4ub[0][0] * alpha;
13948                 c4f[ 1] = decal->color4ub[0][1] * alpha;
13949                 c4f[ 2] = decal->color4ub[0][2] * alpha;
13950                 c4f[ 3] = 1;
13951                 c4f[ 4] = decal->color4ub[1][0] * alpha;
13952                 c4f[ 5] = decal->color4ub[1][1] * alpha;
13953                 c4f[ 6] = decal->color4ub[1][2] * alpha;
13954                 c4f[ 7] = 1;
13955                 c4f[ 8] = decal->color4ub[2][0] * alpha;
13956                 c4f[ 9] = decal->color4ub[2][1] * alpha;
13957                 c4f[10] = decal->color4ub[2][2] * alpha;
13958                 c4f[11] = 1;
13959
13960                 t2f[0] = decal->texcoord2f[0][0];
13961                 t2f[1] = decal->texcoord2f[0][1];
13962                 t2f[2] = decal->texcoord2f[1][0];
13963                 t2f[3] = decal->texcoord2f[1][1];
13964                 t2f[4] = decal->texcoord2f[2][0];
13965                 t2f[5] = decal->texcoord2f[2][1];
13966
13967                 // update vertex positions for animated models
13968                 if (decal->triangleindex >= 0 && decal->triangleindex < rsurface.modelnumtriangles)
13969                 {
13970                         e = rsurface.modelelement3i + 3*decal->triangleindex;
13971                         VectorCopy(rsurface.modelvertexposition[e[0]].vertex3f, v3f);
13972                         VectorCopy(rsurface.modelvertexposition[e[1]].vertex3f, v3f + 3);
13973                         VectorCopy(rsurface.modelvertexposition[e[2]].vertex3f, v3f + 6);
13974                 }
13975                 else
13976                 {
13977                         VectorCopy(decal->vertex3f[0], v3f);
13978                         VectorCopy(decal->vertex3f[1], v3f + 3);
13979                         VectorCopy(decal->vertex3f[2], v3f + 6);
13980                 }
13981
13982                 if (r_refdef.fogenabled)
13983                 {
13984                         alpha = RSurf_FogVertex(v3f);
13985                         VectorScale(c4f, alpha, c4f);
13986                         alpha = RSurf_FogVertex(v3f + 3);
13987                         VectorScale(c4f + 4, alpha, c4f + 4);
13988                         alpha = RSurf_FogVertex(v3f + 6);
13989                         VectorScale(c4f + 8, alpha, c4f + 8);
13990                 }
13991
13992                 v3f += 9;
13993                 c4f += 12;
13994                 t2f += 6;
13995                 numtris++;
13996         }
13997
13998         if (numtris > 0)
13999         {
14000                 r_refdef.stats.drawndecals += numtris;
14001
14002                 // now render the decals all at once
14003                 // (this assumes they all use one particle font texture!)
14004                 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);
14005                 R_Mesh_ResetTextureState();
14006                 R_Mesh_PrepareVertices_Generic_Arrays(numtris * 3, decalsystem->vertex3f, decalsystem->color4f, decalsystem->texcoord2f);
14007                 GL_DepthMask(false);
14008                 GL_DepthRange(0, 1);
14009                 GL_PolygonOffset(rsurface.basepolygonfactor + r_polygonoffset_decals_factor.value, rsurface.basepolygonoffset + r_polygonoffset_decals_offset.value);
14010                 GL_DepthTest(true);
14011                 GL_CullFace(GL_NONE);
14012                 GL_BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
14013                 R_SetupShader_Generic(decalskinframe->base, NULL, GL_MODULATE, 1);
14014                 R_Mesh_Draw(0, numtris * 3, 0, numtris, decalsystem->element3i, NULL, 0, decalsystem->element3s, NULL, 0);
14015         }
14016 }
14017
14018 static void R_DrawModelDecals(void)
14019 {
14020         int i, numdecals;
14021
14022         // fade faster when there are too many decals
14023         numdecals = r_refdef.scene.worldentity->decalsystem.numdecals;
14024         for (i = 0;i < r_refdef.scene.numentities;i++)
14025                 numdecals += r_refdef.scene.entities[i]->decalsystem.numdecals;
14026
14027         R_DrawModelDecals_FadeEntity(r_refdef.scene.worldentity);
14028         for (i = 0;i < r_refdef.scene.numentities;i++)
14029                 if (r_refdef.scene.entities[i]->decalsystem.numdecals)
14030                         R_DrawModelDecals_FadeEntity(r_refdef.scene.entities[i]);
14031
14032         R_DecalSystem_ApplySplatEntitiesQueue();
14033
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_refdef.stats.totaldecals += numdecals;
14039
14040         if (r_showsurfaces.integer)
14041                 return;
14042
14043         R_DrawModelDecals_Entity(r_refdef.scene.worldentity);
14044
14045         for (i = 0;i < r_refdef.scene.numentities;i++)
14046         {
14047                 if (!r_refdef.viewcache.entityvisible[i])
14048                         continue;
14049                 if (r_refdef.scene.entities[i]->decalsystem.numdecals)
14050                         R_DrawModelDecals_Entity(r_refdef.scene.entities[i]);
14051         }
14052 }
14053
14054 extern cvar_t mod_collision_bih;
14055 void R_DrawDebugModel(void)
14056 {
14057         entity_render_t *ent = rsurface.entity;
14058         int i, j, k, l, flagsmask;
14059         const msurface_t *surface;
14060         dp_model_t *model = ent->model;
14061         vec3_t v;
14062
14063         switch(vid.renderpath)
14064         {
14065         case RENDERPATH_GL11:
14066         case RENDERPATH_GL13:
14067         case RENDERPATH_GL20:
14068         case RENDERPATH_CGGL:
14069                 break;
14070         case RENDERPATH_D3D9:
14071                 //Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
14072                 return;
14073         case RENDERPATH_D3D10:
14074                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
14075                 return;
14076         case RENDERPATH_D3D11:
14077                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
14078                 return;
14079         }
14080
14081         flagsmask = MATERIALFLAG_SKY | MATERIALFLAG_WALL;
14082
14083         R_Mesh_ResetTextureState();
14084         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
14085         GL_DepthRange(0, 1);
14086         GL_DepthTest(!r_showdisabledepthtest.integer);
14087         GL_DepthMask(false);
14088         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
14089
14090         if (r_showcollisionbrushes.value > 0 && model->collision_bih.numleafs)
14091         {
14092                 int triangleindex;
14093                 int bihleafindex;
14094                 qboolean cullbox = ent == r_refdef.scene.worldentity;
14095                 const q3mbrush_t *brush;
14096                 const bih_t *bih = &model->collision_bih;
14097                 const bih_leaf_t *bihleaf;
14098                 float vertex3f[3][3];
14099                 GL_PolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);
14100                 cullbox = false;
14101                 for (bihleafindex = 0, bihleaf = bih->leafs;bihleafindex < bih->numleafs;bihleafindex++, bihleaf++)
14102                 {
14103                         if (cullbox && R_CullBox(bihleaf->mins, bihleaf->maxs))
14104                                 continue;
14105                         switch (bihleaf->type)
14106                         {
14107                         case BIH_BRUSH:
14108                                 brush = model->brush.data_brushes + bihleaf->itemindex;
14109                                 if (brush->colbrushf && brush->colbrushf->numtriangles)
14110                                 {
14111                                         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);
14112                                         R_Mesh_PrepareVertices_Generic_Arrays(brush->colbrushf->numpoints, brush->colbrushf->points->v, NULL, NULL);
14113                                         R_Mesh_Draw(0, brush->colbrushf->numpoints, 0, brush->colbrushf->numtriangles, brush->colbrushf->elements, NULL, 0, NULL, NULL, 0);
14114                                 }
14115                                 break;
14116                         case BIH_COLLISIONTRIANGLE:
14117                                 triangleindex = bihleaf->itemindex;
14118                                 VectorCopy(model->brush.data_collisionvertex3f + 3*model->brush.data_collisionelement3i[triangleindex*3+0], vertex3f[0]);
14119                                 VectorCopy(model->brush.data_collisionvertex3f + 3*model->brush.data_collisionelement3i[triangleindex*3+1], vertex3f[1]);
14120                                 VectorCopy(model->brush.data_collisionvertex3f + 3*model->brush.data_collisionelement3i[triangleindex*3+2], vertex3f[2]);
14121                                 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);
14122                                 R_Mesh_PrepareVertices_Generic_Arrays(3, vertex3f[0], NULL, NULL);
14123                                 R_Mesh_Draw(0, 3, 0, 1, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
14124                                 break;
14125                         case BIH_RENDERTRIANGLE:
14126                                 triangleindex = bihleaf->itemindex;
14127                                 VectorCopy(model->surfmesh.data_vertex3f + 3*model->surfmesh.data_element3i[triangleindex*3+0], vertex3f[0]);
14128                                 VectorCopy(model->surfmesh.data_vertex3f + 3*model->surfmesh.data_element3i[triangleindex*3+1], vertex3f[1]);
14129                                 VectorCopy(model->surfmesh.data_vertex3f + 3*model->surfmesh.data_element3i[triangleindex*3+2], vertex3f[2]);
14130                                 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);
14131                                 R_Mesh_PrepareVertices_Generic_Arrays(3, vertex3f[0], NULL, NULL);
14132                                 R_Mesh_Draw(0, 3, 0, 1, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
14133                                 break;
14134                         }
14135                 }
14136         }
14137
14138         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
14139
14140         if (r_showtris.integer || r_shownormals.integer)
14141         {
14142                 if (r_showdisabledepthtest.integer)
14143                 {
14144                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
14145                         GL_DepthMask(false);
14146                 }
14147                 else
14148                 {
14149                         GL_BlendFunc(GL_ONE, GL_ZERO);
14150                         GL_DepthMask(true);
14151                 }
14152                 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
14153                 {
14154                         if (ent == r_refdef.scene.worldentity && !r_refdef.viewcache.world_surfacevisible[j])
14155                                 continue;
14156                         rsurface.texture = R_GetCurrentTexture(surface->texture);
14157                         if ((rsurface.texture->currentmaterialflags & flagsmask) && surface->num_triangles)
14158                         {
14159                                 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | BATCHNEED_NOGAPS, 1, &surface);
14160                                 if (r_showtris.value > 0)
14161                                 {
14162                                         if (!rsurface.texture->currentlayers->depthmask)
14163                                                 GL_Color(r_refdef.view.colorscale, 0, 0, r_showtris.value);
14164                                         else if (ent == r_refdef.scene.worldentity)
14165                                                 GL_Color(r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale, r_showtris.value);
14166                                         else
14167                                                 GL_Color(0, r_refdef.view.colorscale, 0, r_showtris.value);
14168                                         R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, NULL, NULL);
14169                                         qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
14170                                         RSurf_DrawBatch();
14171                                         qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
14172                                         CHECKGLERROR
14173                                 }
14174                                 if (r_shownormals.value < 0)
14175                                 {
14176                                         qglBegin(GL_LINES);
14177                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
14178                                         {
14179                                                 VectorCopy(rsurface.batchvertex3f + l * 3, v);
14180                                                 GL_Color(r_refdef.view.colorscale, 0, 0, 1);
14181                                                 qglVertex3f(v[0], v[1], v[2]);
14182                                                 VectorMA(v, -r_shownormals.value, rsurface.batchsvector3f + l * 3, v);
14183                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
14184                                                 qglVertex3f(v[0], v[1], v[2]);
14185                                         }
14186                                         qglEnd();
14187                                         CHECKGLERROR
14188                                 }
14189                                 if (r_shownormals.value > 0 && rsurface.batchsvector3f)
14190                                 {
14191                                         qglBegin(GL_LINES);
14192                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
14193                                         {
14194                                                 VectorCopy(rsurface.batchvertex3f + l * 3, v);
14195                                                 GL_Color(r_refdef.view.colorscale, 0, 0, 1);
14196                                                 qglVertex3f(v[0], v[1], v[2]);
14197                                                 VectorMA(v, r_shownormals.value, rsurface.batchsvector3f + l * 3, v);
14198                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
14199                                                 qglVertex3f(v[0], v[1], v[2]);
14200                                         }
14201                                         qglEnd();
14202                                         CHECKGLERROR
14203                                         qglBegin(GL_LINES);
14204                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
14205                                         {
14206                                                 VectorCopy(rsurface.batchvertex3f + l * 3, v);
14207                                                 GL_Color(0, r_refdef.view.colorscale, 0, 1);
14208                                                 qglVertex3f(v[0], v[1], v[2]);
14209                                                 VectorMA(v, r_shownormals.value, rsurface.batchtvector3f + l * 3, v);
14210                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
14211                                                 qglVertex3f(v[0], v[1], v[2]);
14212                                         }
14213                                         qglEnd();
14214                                         CHECKGLERROR
14215                                         qglBegin(GL_LINES);
14216                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
14217                                         {
14218                                                 VectorCopy(rsurface.batchvertex3f + l * 3, v);
14219                                                 GL_Color(0, 0, r_refdef.view.colorscale, 1);
14220                                                 qglVertex3f(v[0], v[1], v[2]);
14221                                                 VectorMA(v, r_shownormals.value, rsurface.batchnormal3f + l * 3, v);
14222                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
14223                                                 qglVertex3f(v[0], v[1], v[2]);
14224                                         }
14225                                         qglEnd();
14226                                         CHECKGLERROR
14227                                 }
14228                         }
14229                 }
14230                 rsurface.texture = NULL;
14231         }
14232 }
14233
14234 extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
14235 int r_maxsurfacelist = 0;
14236 const msurface_t **r_surfacelist = NULL;
14237 void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass)
14238 {
14239         int i, j, endj, flagsmask;
14240         dp_model_t *model = r_refdef.scene.worldmodel;
14241         msurface_t *surfaces;
14242         unsigned char *update;
14243         int numsurfacelist = 0;
14244         if (model == NULL)
14245                 return;
14246
14247         if (r_maxsurfacelist < model->num_surfaces)
14248         {
14249                 r_maxsurfacelist = model->num_surfaces;
14250                 if (r_surfacelist)
14251                         Mem_Free((msurface_t**)r_surfacelist);
14252                 r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist));
14253         }
14254
14255         RSurf_ActiveWorldEntity();
14256
14257         surfaces = model->data_surfaces;
14258         update = model->brushq1.lightmapupdateflags;
14259
14260         // update light styles on this submodel
14261         if (!skysurfaces && !depthonly && !prepass && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
14262         {
14263                 model_brush_lightstyleinfo_t *style;
14264                 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
14265                 {
14266                         if (style->value != r_refdef.scene.lightstylevalue[style->style])
14267                         {
14268                                 int *list = style->surfacelist;
14269                                 style->value = r_refdef.scene.lightstylevalue[style->style];
14270                                 for (j = 0;j < style->numsurfaces;j++)
14271                                         update[list[j]] = true;
14272                         }
14273                 }
14274         }
14275
14276         flagsmask = skysurfaces ? MATERIALFLAG_SKY : MATERIALFLAG_WALL;
14277
14278         if (debug)
14279         {
14280                 R_DrawDebugModel();
14281                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
14282                 return;
14283         }
14284
14285         rsurface.lightmaptexture = NULL;
14286         rsurface.deluxemaptexture = NULL;
14287         rsurface.uselightmaptexture = false;
14288         rsurface.texture = NULL;
14289         rsurface.rtlight = NULL;
14290         numsurfacelist = 0;
14291         // add visible surfaces to draw list
14292         for (i = 0;i < model->nummodelsurfaces;i++)
14293         {
14294                 j = model->sortedmodelsurfaces[i];
14295                 if (r_refdef.viewcache.world_surfacevisible[j])
14296                         r_surfacelist[numsurfacelist++] = surfaces + j;
14297         }
14298         // update lightmaps if needed
14299         if (model->brushq1.firstrender)
14300         {
14301                 model->brushq1.firstrender = false;
14302                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
14303                         if (update[j])
14304                                 R_BuildLightMap(r_refdef.scene.worldentity, surfaces + j);
14305         }
14306         else if (update)
14307         {
14308                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
14309                         if (r_refdef.viewcache.world_surfacevisible[j])
14310                                 if (update[j])
14311                                         R_BuildLightMap(r_refdef.scene.worldentity, surfaces + j);
14312         }
14313         // don't do anything if there were no surfaces
14314         if (!numsurfacelist)
14315         {
14316                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
14317                 return;
14318         }
14319         R_QueueWorldSurfaceList(numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
14320         GL_AlphaTest(false);
14321
14322         // add to stats if desired
14323         if (r_speeds.integer && !skysurfaces && !depthonly)
14324         {
14325                 r_refdef.stats.world_surfaces += numsurfacelist;
14326                 for (j = 0;j < numsurfacelist;j++)
14327                         r_refdef.stats.world_triangles += r_surfacelist[j]->num_triangles;
14328         }
14329
14330         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
14331 }
14332
14333 void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass)
14334 {
14335         int i, j, endj, flagsmask;
14336         dp_model_t *model = ent->model;
14337         msurface_t *surfaces;
14338         unsigned char *update;
14339         int numsurfacelist = 0;
14340         if (model == NULL)
14341                 return;
14342
14343         if (r_maxsurfacelist < model->num_surfaces)
14344         {
14345                 r_maxsurfacelist = model->num_surfaces;
14346                 if (r_surfacelist)
14347                         Mem_Free((msurface_t **)r_surfacelist);
14348                 r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist));
14349         }
14350
14351         // if the model is static it doesn't matter what value we give for
14352         // wantnormals and wanttangents, so this logic uses only rules applicable
14353         // to a model, knowing that they are meaningless otherwise
14354         if (ent == r_refdef.scene.worldentity)
14355                 RSurf_ActiveWorldEntity();
14356         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
14357                 RSurf_ActiveModelEntity(ent, false, false, false);
14358         else if (prepass)
14359                 RSurf_ActiveModelEntity(ent, true, true, true);
14360         else if (depthonly)
14361         {
14362                 switch (vid.renderpath)
14363                 {
14364                 case RENDERPATH_GL20:
14365                 case RENDERPATH_CGGL:
14366                 case RENDERPATH_D3D9:
14367                 case RENDERPATH_D3D10:
14368                 case RENDERPATH_D3D11:
14369                         RSurf_ActiveModelEntity(ent, model->wantnormals, model->wanttangents, false);
14370                         break;
14371                 case RENDERPATH_GL13:
14372                 case RENDERPATH_GL11:
14373                         RSurf_ActiveModelEntity(ent, model->wantnormals, false, false);
14374                         break;
14375                 }
14376         }
14377         else
14378         {
14379                 switch (vid.renderpath)
14380                 {
14381                 case RENDERPATH_GL20:
14382                 case RENDERPATH_CGGL:
14383                 case RENDERPATH_D3D9:
14384                 case RENDERPATH_D3D10:
14385                 case RENDERPATH_D3D11:
14386                         RSurf_ActiveModelEntity(ent, true, true, false);
14387                         break;
14388                 case RENDERPATH_GL13:
14389                 case RENDERPATH_GL11:
14390                         RSurf_ActiveModelEntity(ent, true, false, false);
14391                         break;
14392                 }
14393         }
14394
14395         surfaces = model->data_surfaces;
14396         update = model->brushq1.lightmapupdateflags;
14397
14398         // update light styles
14399         if (!skysurfaces && !depthonly && !prepass && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
14400         {
14401                 model_brush_lightstyleinfo_t *style;
14402                 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
14403                 {
14404                         if (style->value != r_refdef.scene.lightstylevalue[style->style])
14405                         {
14406                                 int *list = style->surfacelist;
14407                                 style->value = r_refdef.scene.lightstylevalue[style->style];
14408                                 for (j = 0;j < style->numsurfaces;j++)
14409                                         update[list[j]] = true;
14410                         }
14411                 }
14412         }
14413
14414         flagsmask = skysurfaces ? MATERIALFLAG_SKY : MATERIALFLAG_WALL;
14415
14416         if (debug)
14417         {
14418                 R_DrawDebugModel();
14419                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
14420                 return;
14421         }
14422
14423         rsurface.lightmaptexture = NULL;
14424         rsurface.deluxemaptexture = NULL;
14425         rsurface.uselightmaptexture = false;
14426         rsurface.texture = NULL;
14427         rsurface.rtlight = NULL;
14428         numsurfacelist = 0;
14429         // add visible surfaces to draw list
14430         for (i = 0;i < model->nummodelsurfaces;i++)
14431                 r_surfacelist[numsurfacelist++] = surfaces + model->sortedmodelsurfaces[i];
14432         // don't do anything if there were no surfaces
14433         if (!numsurfacelist)
14434         {
14435                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
14436                 return;
14437         }
14438         // update lightmaps if needed
14439         if (update)
14440         {
14441                 int updated = 0;
14442                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
14443                 {
14444                         if (update[j])
14445                         {
14446                                 updated++;
14447                                 R_BuildLightMap(ent, surfaces + j);
14448                         }
14449                 }
14450         }
14451         if (update)
14452                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
14453                         if (update[j])
14454                                 R_BuildLightMap(ent, surfaces + j);
14455         R_QueueModelSurfaceList(ent, numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
14456         GL_AlphaTest(false);
14457
14458         // add to stats if desired
14459         if (r_speeds.integer && !skysurfaces && !depthonly)
14460         {
14461                 r_refdef.stats.entities_surfaces += numsurfacelist;
14462                 for (j = 0;j < numsurfacelist;j++)
14463                         r_refdef.stats.entities_triangles += r_surfacelist[j]->num_triangles;
14464         }
14465
14466         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
14467 }
14468
14469 void R_DrawCustomSurface(skinframe_t *skinframe, const matrix4x4_t *texmatrix, int materialflags, int firstvertex, int numvertices, int firsttriangle, int numtriangles, qboolean writedepth, qboolean prepass)
14470 {
14471         static texture_t texture;
14472         static msurface_t surface;
14473         const msurface_t *surfacelist = &surface;
14474
14475         // fake enough texture and surface state to render this geometry
14476
14477         texture.update_lastrenderframe = -1; // regenerate this texture
14478         texture.basematerialflags = materialflags | MATERIALFLAG_CUSTOMSURFACE | MATERIALFLAG_WALL;
14479         texture.currentskinframe = skinframe;
14480         texture.currenttexmatrix = *texmatrix; // requires MATERIALFLAG_CUSTOMSURFACE
14481         texture.offsetmapping = OFFSETMAPPING_OFF;
14482         texture.offsetscale = 1;
14483         texture.specularscalemod = 1;
14484         texture.specularpowermod = 1;
14485
14486         surface.texture = &texture;
14487         surface.num_triangles = numtriangles;
14488         surface.num_firsttriangle = firsttriangle;
14489         surface.num_vertices = numvertices;
14490         surface.num_firstvertex = firstvertex;
14491
14492         // now render it
14493         rsurface.texture = R_GetCurrentTexture(surface.texture);
14494         rsurface.lightmaptexture = NULL;
14495         rsurface.deluxemaptexture = NULL;
14496         rsurface.uselightmaptexture = false;
14497         R_DrawModelTextureSurfaceList(1, &surfacelist, writedepth, prepass);
14498 }
14499
14500 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)
14501 {
14502         static msurface_t surface;
14503         const msurface_t *surfacelist = &surface;
14504
14505         // fake enough texture and surface state to render this geometry
14506
14507         surface.texture = texture;
14508         surface.num_triangles = numtriangles;
14509         surface.num_firsttriangle = firsttriangle;
14510         surface.num_vertices = numvertices;
14511         surface.num_firstvertex = firstvertex;
14512
14513         // now render it
14514         rsurface.texture = R_GetCurrentTexture(surface.texture);
14515         rsurface.lightmaptexture = NULL;
14516         rsurface.deluxemaptexture = NULL;
14517         rsurface.uselightmaptexture = false;
14518         R_DrawModelTextureSurfaceList(1, &surfacelist, writedepth, prepass);
14519 }