gl_rmain.c

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 See the GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 */
  20 // r_main.c
  21
  22 #include "quakedef.h"
  23 #include "cl_dyntexture.h"
  24 #include "r_shadow.h"
  25 #include "polygon.h"
  26 #include "image.h"
  27 #include "ft2.h"
  28 #include "csprogs.h"
  29 #include "cl_video.h"
  30
  31 mempool_t *r_main_mempool;
  32 rtexturepool_t *r_main_texturepool;
  33
  34 static int r_textureframe = 0; ///< used only by R_GetCurrentTexture
  35
  36 static qboolean r_loadnormalmap;
  37 static qboolean r_loadgloss;
  38 qboolean r_loadfog;
  39 static qboolean r_loaddds;
  40 static qboolean r_savedds;
  41
  42 //
  43 // screen size info
  44 //
  45 r_refdef_t r_refdef;
  46
  47 cvar_t r_motionblur = {CVAR_SAVE, "r_motionblur", "0", "motionblur value scale - 0.5 recommended"};
  48 cvar_t r_damageblur = {CVAR_SAVE, "r_damageblur", "0", "motionblur based on damage"};
  49 cvar_t r_motionblur_vmin = {CVAR_SAVE, "r_motionblur_vmin", "300", "minimum influence from velocity"};
  50 cvar_t r_motionblur_vmax = {CVAR_SAVE, "r_motionblur_vmax", "600", "maximum influence from velocity"};
  51 cvar_t r_motionblur_bmin = {CVAR_SAVE, "r_motionblur_bmin", "0.5", "velocity at which there is no blur yet (may be negative to always have some blur)"};
  52 cvar_t r_motionblur_vcoeff = {CVAR_SAVE, "r_motionblur_vcoeff", "0.05", "sliding average reaction time for velocity"};
  53 cvar_t r_motionblur_maxblur = {CVAR_SAVE, "r_motionblur_maxblur", "0.88", "cap for motionblur alpha value"};
  54 cvar_t r_motionblur_randomize = {CVAR_SAVE, "r_motionblur_randomize", "0.1", "randomizing coefficient to workaround ghosting"};
  55
  56 // TODO do we want a r_equalize_entities cvar that works on all ents, or would that be a cheat?
  57 cvar_t r_equalize_entities_fullbright = {CVAR_SAVE, "r_equalize_entities_fullbright", "0", "render fullbright entities by equalizing their lightness, not by not rendering light"};
  58 cvar_t r_equalize_entities_minambient = {CVAR_SAVE, "r_equalize_entities_minambient", "0.5", "light equalizing: ensure at least this ambient/diffuse ratio"};
  59 cvar_t r_equalize_entities_by = {CVAR_SAVE, "r_equalize_entities_by", "0.7", "light equalizing: exponent of dynamics compression (0 = no compression, 1 = full compression)"};
  60 cvar_t r_equalize_entities_to = {CVAR_SAVE, "r_equalize_entities_to", "0.8", "light equalizing: target light level"};
  61
  62 cvar_t r_depthfirst = {CVAR_SAVE, "r_depthfirst", "0", "renders a depth-only version of the scene before normal rendering begins to eliminate overdraw, values: 0 = off, 1 = world depth, 2 = world and model depth"};
  63 cvar_t r_useinfinitefarclip = {CVAR_SAVE, "r_useinfinitefarclip", "1", "enables use of a special kind of projection matrix that has an extremely large farclip"};
  64 cvar_t r_farclip_base = {0, "r_farclip_base", "65536", "farclip (furthest visible distance) for rendering when r_useinfinitefarclip is 0"};
  65 cvar_t r_farclip_world = {0, "r_farclip_world", "2", "adds map size to farclip multiplied by this value"};
  66 cvar_t r_nearclip = {0, "r_nearclip", "1", "distance from camera of nearclip plane" };
  67 cvar_t r_showbboxes = {0, "r_showbboxes", "0", "shows bounding boxes of server entities, value controls opacity scaling (1 = 10%,  10 = 100%)"};
  68 cvar_t r_showsurfaces = {0, "r_showsurfaces", "0", "1 shows surfaces as different colors, or a value of 2 shows triangle draw order (for analyzing whether meshes are optimized for vertex cache)"};
  69 cvar_t r_showtris = {0, "r_showtris", "0", "shows triangle outlines, value controls brightness (can be above 1)"};
  70 cvar_t r_shownormals = {0, "r_shownormals", "0", "shows per-vertex surface normals and tangent vectors for bumpmapped lighting"};
  71 cvar_t r_showlighting = {0, "r_showlighting", "0", "shows areas lit by lights, useful for finding out why some areas of a map render slowly (bright orange = lots of passes = slow), a value of 2 disables depth testing which can be interesting but not very useful"};
  72 cvar_t r_showshadowvolumes = {0, "r_showshadowvolumes", "0", "shows areas shadowed by lights, useful for finding out why some areas of a map render slowly (bright blue = lots of passes = slow), a value of 2 disables depth testing which can be interesting but not very useful"};
  73 cvar_t r_showcollisionbrushes = {0, "r_showcollisionbrushes", "0", "draws collision brushes in quake3 maps (mode 1), mode 2 disables rendering of world (trippy!)"};
  74 cvar_t r_showcollisionbrushes_polygonfactor = {0, "r_showcollisionbrushes_polygonfactor", "-1", "expands outward the brush polygons a little bit, used to make collision brushes appear infront of walls"};
  75 cvar_t r_showcollisionbrushes_polygonoffset = {0, "r_showcollisionbrushes_polygonoffset", "0", "nudges brush polygon depth in hardware depth units, used to make collision brushes appear infront of walls"};
  76 cvar_t r_showdisabledepthtest = {0, "r_showdisabledepthtest", "0", "disables depth testing on r_show* cvars, allowing you to see what hidden geometry the graphics card is processing"};
  77 cvar_t r_drawportals = {0, "r_drawportals", "0", "shows portals (separating polygons) in world interior in quake1 maps"};
  78 cvar_t r_drawentities = {0, "r_drawentities","1", "draw entities (doors, players, projectiles, etc)"};
  79 cvar_t r_draw2d = {0, "r_draw2d","1", "draw 2D stuff (dangerous to turn off)"};
  80 cvar_t r_drawworld = {0, "r_drawworld","1", "draw world (most static stuff)"};
  81 cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1", "draw your weapon model"};
  82 cvar_t r_drawexteriormodel = {0, "r_drawexteriormodel","1", "draw your player model (e.g. in chase cam, reflections)"};
  83 cvar_t r_cullentities_trace = {0, "r_cullentities_trace", "1", "probabistically cull invisible entities"};
  84 cvar_t r_cullentities_trace_samples = {0, "r_cullentities_trace_samples", "2", "number of samples to test for entity culling (in addition to center sample)"};
  85 cvar_t r_cullentities_trace_tempentitysamples = {0, "r_cullentities_trace_tempentitysamples", "-1", "number of samples to test for entity culling of temp entities (including all CSQC entities), -1 disables trace culling on these entities to prevent flicker (pvs still applies)"};
  86 cvar_t r_cullentities_trace_enlarge = {0, "r_cullentities_trace_enlarge", "0", "box enlargement for entity culling"};
  87 cvar_t r_cullentities_trace_delay = {0, "r_cullentities_trace_delay", "1", "number of seconds until the entity gets actually culled"};
  88 cvar_t r_speeds = {0, "r_speeds","0", "displays rendering statistics and per-subsystem timings"};
  89 cvar_t r_fullbright = {0, "r_fullbright","0", "makes map very bright and renders faster"};
  90 cvar_t r_wateralpha = {CVAR_SAVE, "r_wateralpha","1", "opacity of water polygons"};
  91 cvar_t r_dynamic = {CVAR_SAVE, "r_dynamic","1", "enables dynamic lights (rocket glow and such)"};
  92 cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1", "enables glowing pixels in quake textures (changes need r_restart to take effect)"};
  93 cvar_t r_shadows = {CVAR_SAVE, "r_shadows", "0", "casts fake stencil shadows from models onto the world (rtlights are unaffected by this); when set to 2, always cast the shadows in the direction set by r_shadows_throwdirection, otherwise use the model lighting."};
  94 cvar_t r_shadows_darken = {CVAR_SAVE, "r_shadows_darken", "0.5", "how much shadowed areas will be darkened"};
  95 cvar_t r_shadows_throwdistance = {CVAR_SAVE, "r_shadows_throwdistance", "500", "how far to cast shadows from models"};
  96 cvar_t r_shadows_throwdirection = {CVAR_SAVE, "r_shadows_throwdirection", "0 0 -1", "override throwing direction for r_shadows 2"};
  97 cvar_t r_shadows_drawafterrtlighting = {CVAR_SAVE, "r_shadows_drawafterrtlighting", "0", "draw fake shadows AFTER realtime lightning is drawn. May be useful for simulating fast sunlight on large outdoor maps with only one noshadow rtlight. The price is less realistic appearance of dynamic light shadows."};
  98 cvar_t r_shadows_castfrombmodels = {CVAR_SAVE, "r_shadows_castfrombmodels", "0", "do cast shadows from bmodels"};
  99 cvar_t r_shadows_focus = {CVAR_SAVE, "r_shadows_focus", "0 0 0", "offset the shadowed area focus"};
 100 cvar_t r_shadows_shadowmapscale = {CVAR_SAVE, "r_shadows_shadowmapscale", "1", "increases shadowmap quality (multiply global shadowmap precision) for fake shadows. Needs shadowmapping ON."};
 101 cvar_t r_q1bsp_skymasking = {0, "r_q1bsp_skymasking", "1", "allows sky polygons in quake1 maps to obscure other geometry"};
 102 cvar_t r_polygonoffset_submodel_factor = {0, "r_polygonoffset_submodel_factor", "0", "biases depth values of world submodels such as doors, to prevent z-fighting artifacts in Quake maps"};
 103 cvar_t r_polygonoffset_submodel_offset = {0, "r_polygonoffset_submodel_offset", "14", "biases depth values of world submodels such as doors, to prevent z-fighting artifacts in Quake maps"};
 104 cvar_t r_polygonoffset_decals_factor = {0, "r_polygonoffset_decals_factor", "0", "biases depth values of decals to prevent z-fighting artifacts"};
 105 cvar_t r_polygonoffset_decals_offset = {0, "r_polygonoffset_decals_offset", "-14", "biases depth values of decals to prevent z-fighting artifacts"};
 106 cvar_t r_fog_exp2 = {0, "r_fog_exp2", "0", "uses GL_EXP2 fog (as in Nehahra) rather than realistic GL_EXP fog"};
 107 cvar_t r_drawfog = {CVAR_SAVE, "r_drawfog", "1", "allows one to disable fog rendering"};
 108 cvar_t r_transparentdepthmasking = {CVAR_SAVE, "r_transparentdepthmasking", "0", "enables depth writes on transparent meshes whose materially is normally opaque, this prevents seeing the inside of a transparent mesh"};
 109
 110 cvar_t gl_fogenable = {0, "gl_fogenable", "0", "nehahra fog enable (for Nehahra compatibility only)"};
 111 cvar_t gl_fogdensity = {0, "gl_fogdensity", "0.25", "nehahra fog density (recommend values below 0.1) (for Nehahra compatibility only)"};
 112 cvar_t gl_fogred = {0, "gl_fogred","0.3", "nehahra fog color red value (for Nehahra compatibility only)"};
 113 cvar_t gl_foggreen = {0, "gl_foggreen","0.3", "nehahra fog color green value (for Nehahra compatibility only)"};
 114 cvar_t gl_fogblue = {0, "gl_fogblue","0.3", "nehahra fog color blue value (for Nehahra compatibility only)"};
 115 cvar_t gl_fogstart = {0, "gl_fogstart", "0", "nehahra fog start distance (for Nehahra compatibility only)"};
 116 cvar_t gl_fogend = {0, "gl_fogend","0", "nehahra fog end distance (for Nehahra compatibility only)"};
 117 cvar_t gl_skyclip = {0, "gl_skyclip", "4608", "nehahra farclip distance - the real fog end (for Nehahra compatibility only)"};
 118
 119 cvar_t r_texture_dds_load = {CVAR_SAVE, "r_texture_dds_load", "0", "load compressed dds/filename.dds texture instead of filename.tga, if the file exists (requires driver support)"};
 120 cvar_t r_texture_dds_save = {CVAR_SAVE, "r_texture_dds_save", "0", "save compressed dds/filename.dds texture when filename.tga is loaded, so that it can be loaded instead next time"};
 121
 122 cvar_t r_texture_convertsRGB_2d = {0, "r_texture_convertsRGB_2d", "0", "load textures as sRGB and convert to linear for proper shading"};
 123 cvar_t r_texture_convertsRGB_skin = {0, "r_texture_convertsRGB_skin", "0", "load textures as sRGB and convert to linear for proper shading"};
 124 cvar_t r_texture_convertsRGB_cubemap = {0, "r_texture_convertsRGB_cubemap", "0", "load textures as sRGB and convert to linear for proper shading"};
 125 cvar_t r_texture_convertsRGB_skybox = {0, "r_texture_convertsRGB_skybox", "0", "load textures as sRGB and convert to linear for proper shading"};
 126 cvar_t r_texture_convertsRGB_particles = {0, "r_texture_convertsRGB_particles", "0", "load textures as sRGB and convert to linear for proper shading"};
 127
 128 cvar_t r_textureunits = {0, "r_textureunits", "32", "number of texture units to use in GL 1.1 and GL 1.3 rendering paths"};
 129 static cvar_t gl_combine = {CVAR_READONLY, "gl_combine", "1", "indicates whether the OpenGL 1.3 rendering path is active"};
 130 static cvar_t r_glsl = {CVAR_READONLY, "r_glsl", "1", "indicates whether the OpenGL 2.0 rendering path is active"};
 131
 132 cvar_t r_glsl_deluxemapping = {CVAR_SAVE, "r_glsl_deluxemapping", "1", "use per pixel lighting on deluxemap-compiled q3bsp maps (or a value of 2 forces deluxemap shading even without deluxemaps)"};
 133 cvar_t r_glsl_offsetmapping = {CVAR_SAVE, "r_glsl_offsetmapping", "0", "offset mapping effect (also known as parallax mapping or virtual displacement mapping)"};
 134 cvar_t r_glsl_offsetmapping_reliefmapping = {CVAR_SAVE, "r_glsl_offsetmapping_reliefmapping", "0", "relief mapping effect (higher quality)"};
 135 cvar_t r_glsl_offsetmapping_scale = {CVAR_SAVE, "r_glsl_offsetmapping_scale", "0.04", "how deep the offset mapping effect is"};
 136 cvar_t r_glsl_postprocess = {CVAR_SAVE, "r_glsl_postprocess", "0", "use a GLSL postprocessing shader"};
 137 cvar_t r_glsl_postprocess_uservec1 = {CVAR_SAVE, "r_glsl_postprocess_uservec1", "0 0 0 0", "a 4-component vector to pass as uservec1 to the postprocessing shader (only useful if default.glsl has been customized)"};
 138 cvar_t r_glsl_postprocess_uservec2 = {CVAR_SAVE, "r_glsl_postprocess_uservec2", "0 0 0 0", "a 4-component vector to pass as uservec2 to the postprocessing shader (only useful if default.glsl has been customized)"};
 139 cvar_t r_glsl_postprocess_uservec3 = {CVAR_SAVE, "r_glsl_postprocess_uservec3", "0 0 0 0", "a 4-component vector to pass as uservec3 to the postprocessing shader (only useful if default.glsl has been customized)"};
 140 cvar_t r_glsl_postprocess_uservec4 = {CVAR_SAVE, "r_glsl_postprocess_uservec4", "0 0 0 0", "a 4-component vector to pass as uservec4 to the postprocessing shader (only useful if default.glsl has been customized)"};
 141
 142 cvar_t r_water = {CVAR_SAVE, "r_water", "0", "whether to use reflections and refraction on water surfaces (note: r_wateralpha must be set below 1)"};
 143 cvar_t r_water_clippingplanebias = {CVAR_SAVE, "r_water_clippingplanebias", "1", "a rather technical setting which avoids black pixels around water edges"};
 144 cvar_t r_water_resolutionmultiplier = {CVAR_SAVE, "r_water_resolutionmultiplier", "0.5", "multiplier for screen resolution when rendering refracted/reflected scenes, 1 is full quality, lower values are faster"};
 145 cvar_t r_water_refractdistort = {CVAR_SAVE, "r_water_refractdistort", "0.01", "how much water refractions shimmer"};
 146 cvar_t r_water_reflectdistort = {CVAR_SAVE, "r_water_reflectdistort", "0.01", "how much water reflections shimmer"};
 147
 148 cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "0", "enables animation smoothing on sprites"};
 149 cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1", "enables animation smoothing on models"};
 150 cvar_t r_lerplightstyles = {CVAR_SAVE, "r_lerplightstyles", "0", "enable animation smoothing on flickering lights"};
 151 cvar_t r_waterscroll = {CVAR_SAVE, "r_waterscroll", "1", "makes water scroll around, value controls how much"};
 152
 153 cvar_t r_bloom = {CVAR_SAVE, "r_bloom", "0", "enables bloom effect (makes bright pixels affect neighboring pixels)"};
 154 cvar_t r_bloom_colorscale = {CVAR_SAVE, "r_bloom_colorscale", "1", "how bright the glow is"};
 155 cvar_t r_bloom_brighten = {CVAR_SAVE, "r_bloom_brighten", "2", "how bright the glow is, after subtract/power"};
 156 cvar_t r_bloom_blur = {CVAR_SAVE, "r_bloom_blur", "4", "how large the glow is"};
 157 cvar_t r_bloom_resolution = {CVAR_SAVE, "r_bloom_resolution", "320", "what resolution to perform the bloom effect at (independent of screen resolution)"};
 158 cvar_t r_bloom_colorexponent = {CVAR_SAVE, "r_bloom_colorexponent", "1", "how exagerated the glow is"};
 159 cvar_t r_bloom_colorsubtract = {CVAR_SAVE, "r_bloom_colorsubtract", "0.125", "reduces bloom colors by a certain amount"};
 160
 161 cvar_t r_hdr = {CVAR_SAVE, "r_hdr", "0", "enables High Dynamic Range bloom effect (higher quality version of r_bloom)"};
 162 cvar_t r_hdr_scenebrightness = {CVAR_SAVE, "r_hdr_scenebrightness", "1", "global rendering brightness"};
 163 cvar_t r_hdr_glowintensity = {CVAR_SAVE, "r_hdr_glowintensity", "1", "how bright light emitting textures should appear"};
 164 cvar_t r_hdr_range = {CVAR_SAVE, "r_hdr_range", "4", "how much dynamic range to render bloom with (equivilant to multiplying r_bloom_brighten by this value and dividing r_bloom_colorscale by this value)"};
 165
 166 cvar_t r_smoothnormals_areaweighting = {0, "r_smoothnormals_areaweighting", "1", "uses significantly faster (and supposedly higher quality) area-weighted vertex normals and tangent vectors rather than summing normalized triangle normals and tangents"};
 167
 168 cvar_t developer_texturelogging = {0, "developer_texturelogging", "0", "produces a textures.log file containing names of skins and map textures the engine tried to load"};
 169
 170 cvar_t gl_lightmaps = {0, "gl_lightmaps", "0", "draws only lightmaps, no texture (for level designers)"};
 171
 172 cvar_t r_test = {0, "r_test", "0", "internal development use only, leave it alone (usually does nothing anyway)"};
 173 cvar_t r_batchmode = {0, "r_batchmode", "1", "selects method of rendering multiple surfaces with one driver call (values are 0, 1, 2, etc...)"};
 174 cvar_t r_track_sprites = {CVAR_SAVE, "r_track_sprites", "1", "track SPR_LABEL* sprites by putting them as indicator at the screen border to rotate to"};
 175 cvar_t r_track_sprites_flags = {CVAR_SAVE, "r_track_sprites_flags", "1", "1: Rotate sprites accodringly, 2: Make it a continuous rotation"};
 176 cvar_t r_track_sprites_scalew = {CVAR_SAVE, "r_track_sprites_scalew", "1", "width scaling of tracked sprites"};
 177 cvar_t r_track_sprites_scaleh = {CVAR_SAVE, "r_track_sprites_scaleh", "1", "height scaling of tracked sprites"};
 178 cvar_t r_overheadsprites_perspective = {CVAR_SAVE, "r_overheadsprites_perspective", "0.15", "fake perspective effect for SPR_OVERHEAD sprites"};
 179 cvar_t r_overheadsprites_pushback = {CVAR_SAVE, "r_overheadsprites_pushback", "16", "how far to pull the SPR_OVERHEAD sprites toward the eye (used to avoid intersections with 3D models)"};
 180
 181 cvar_t r_glsl_saturation = {CVAR_SAVE, "r_glsl_saturation", "1", "saturation multiplier (only working in glsl!)"};
 182
 183 cvar_t r_framedatasize = {CVAR_SAVE, "r_framedatasize", "1", "size of renderer data cache used during one frame (for skeletal animation caching, light processing, etc)"};
 184
 185 extern cvar_t v_glslgamma;
 186
 187 extern qboolean v_flipped_state;
 188
 189 static struct r_bloomstate_s
 190 {
 191         qboolean enabled;
 192         qboolean hdr;
 193
 194         int bloomwidth, bloomheight;
 195
 196         int screentexturewidth, screentextureheight;
 197         rtexture_t *texture_screen; /// \note also used for motion blur if enabled!
 198
 199         int bloomtexturewidth, bloomtextureheight;
 200         rtexture_t *texture_bloom;
 201
 202         // arrays for rendering the screen passes
 203         float screentexcoord2f[8];
 204         float bloomtexcoord2f[8];
 205         float offsettexcoord2f[8];
 206
 207         r_viewport_t viewport;
 208 }
 209 r_bloomstate;
 210
 211 r_waterstate_t r_waterstate;
 212
 213 /// shadow volume bsp struct with automatically growing nodes buffer
 214 svbsp_t r_svbsp;
 215
 216 rtexture_t *r_texture_blanknormalmap;
 217 rtexture_t *r_texture_white;
 218 rtexture_t *r_texture_grey128;
 219 rtexture_t *r_texture_black;
 220 rtexture_t *r_texture_notexture;
 221 rtexture_t *r_texture_whitecube;
 222 rtexture_t *r_texture_normalizationcube;
 223 rtexture_t *r_texture_fogattenuation;
 224 rtexture_t *r_texture_fogheighttexture;
 225 rtexture_t *r_texture_gammaramps;
 226 unsigned int r_texture_gammaramps_serial;
 227 //rtexture_t *r_texture_fogintensity;
 228 rtexture_t *r_texture_reflectcube;
 229
 230 // TODO: hash lookups?
 231 typedef struct cubemapinfo_s
 232 {
 233         char basename[64];
 234         rtexture_t *texture;
 235 }
 236 cubemapinfo_t;
 237
 238 int r_texture_numcubemaps;
 239 cubemapinfo_t r_texture_cubemaps[MAX_CUBEMAPS];
 240
 241 unsigned int r_queries[MAX_OCCLUSION_QUERIES];
 242 unsigned int r_numqueries;
 243 unsigned int r_maxqueries;
 244
 245 typedef struct r_qwskincache_s
 246 {
 247         char name[MAX_QPATH];
 248         skinframe_t *skinframe;
 249 }
 250 r_qwskincache_t;
 251
 252 static r_qwskincache_t *r_qwskincache;
 253 static int r_qwskincache_size;
 254
 255 /// vertex coordinates for a quad that covers the screen exactly
 256 const float r_screenvertex3f[12] =
 257 {
 258         0, 0, 0,
 259         1, 0, 0,
 260         1, 1, 0,
 261         0, 1, 0
 262 };
 263
 264 void R_ModulateColors(float *in, float *out, int verts, float r, float g, float b)
 265 {
 266         int i;
 267         for (i = 0;i < verts;i++)
 268         {
 269                 out[0] = in[0] * r;
 270                 out[1] = in[1] * g;
 271                 out[2] = in[2] * b;
 272                 out[3] = in[3];
 273                 in += 4;
 274                 out += 4;
 275         }
 276 }
 277
 278 void R_FillColors(float *out, int verts, float r, float g, float b, float a)
 279 {
 280         int i;
 281         for (i = 0;i < verts;i++)
 282         {
 283                 out[0] = r;
 284                 out[1] = g;
 285                 out[2] = b;
 286                 out[3] = a;
 287                 out += 4;
 288         }
 289 }
 290
 291 // FIXME: move this to client?
 292 void FOG_clear(void)
 293 {
 294         if (gamemode == GAME_NEHAHRA)
 295         {
 296                 Cvar_Set("gl_fogenable", "0");
 297                 Cvar_Set("gl_fogdensity", "0.2");
 298                 Cvar_Set("gl_fogred", "0.3");
 299                 Cvar_Set("gl_foggreen", "0.3");
 300                 Cvar_Set("gl_fogblue", "0.3");
 301         }
 302         r_refdef.fog_density = 0;
 303         r_refdef.fog_red = 0;
 304         r_refdef.fog_green = 0;
 305         r_refdef.fog_blue = 0;
 306         r_refdef.fog_alpha = 1;
 307         r_refdef.fog_start = 0;
 308         r_refdef.fog_end = 16384;
 309         r_refdef.fog_height = 1<<30;
 310         r_refdef.fog_fadedepth = 128;
 311         memset(r_refdef.fog_height_texturename, 0, sizeof(r_refdef.fog_height_texturename));
 312 }
 313
 314 static void R_BuildBlankTextures(void)
 315 {
 316         unsigned char data[4];
 317         data[2] = 128; // normal X
 318         data[1] = 128; // normal Y
 319         data[0] = 255; // normal Z
 320         data[3] = 128; // height
 321         r_texture_blanknormalmap = R_LoadTexture2D(r_main_texturepool, "blankbump", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, -1, NULL);
 322         data[0] = 255;
 323         data[1] = 255;
 324         data[2] = 255;
 325         data[3] = 255;
 326         r_texture_white = R_LoadTexture2D(r_main_texturepool, "blankwhite", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, -1, NULL);
 327         data[0] = 128;
 328         data[1] = 128;
 329         data[2] = 128;
 330         data[3] = 255;
 331         r_texture_grey128 = R_LoadTexture2D(r_main_texturepool, "blankgrey128", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, -1, NULL);
 332         data[0] = 0;
 333         data[1] = 0;
 334         data[2] = 0;
 335         data[3] = 255;
 336         r_texture_black = R_LoadTexture2D(r_main_texturepool, "blankblack", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, -1, NULL);
 337 }
 338
 339 static void R_BuildNoTexture(void)
 340 {
 341         int x, y;
 342         unsigned char pix[16][16][4];
 343         // this makes a light grey/dark grey checkerboard texture
 344         for (y = 0;y < 16;y++)
 345         {
 346                 for (x = 0;x < 16;x++)
 347                 {
 348                         if ((y < 8) ^ (x < 8))
 349                         {
 350                                 pix[y][x][0] = 128;
 351                                 pix[y][x][1] = 128;
 352                                 pix[y][x][2] = 128;
 353                                 pix[y][x][3] = 255;
 354                         }
 355                         else
 356                         {
 357                                 pix[y][x][0] = 64;
 358                                 pix[y][x][1] = 64;
 359                                 pix[y][x][2] = 64;
 360                                 pix[y][x][3] = 255;
 361                         }
 362                 }
 363         }
 364         r_texture_notexture = R_LoadTexture2D(r_main_texturepool, "notexture", 16, 16, &pix[0][0][0], TEXTYPE_BGRA, TEXF_MIPMAP | TEXF_PERSISTENT, -1, NULL);
 365 }
 366
 367 static void R_BuildWhiteCube(void)
 368 {
 369         unsigned char data[6*1*1*4];
 370         memset(data, 255, sizeof(data));
 371         r_texture_whitecube = R_LoadTextureCubeMap(r_main_texturepool, "whitecube", 1, data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL);
 372 }
 373
 374 static void R_BuildNormalizationCube(void)
 375 {
 376         int x, y, side;
 377         vec3_t v;
 378         vec_t s, t, intensity;
 379 #define NORMSIZE 64
 380         unsigned char *data;
 381         data = Mem_Alloc(tempmempool, 6*NORMSIZE*NORMSIZE*4);
 382         for (side = 0;side < 6;side++)
 383         {
 384                 for (y = 0;y < NORMSIZE;y++)
 385                 {
 386                         for (x = 0;x < NORMSIZE;x++)
 387                         {
 388                                 s = (x + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
 389                                 t = (y + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
 390                                 switch(side)
 391                                 {
 392                                 default:
 393                                 case 0:
 394                                         v[0] = 1;
 395                                         v[1] = -t;
 396                                         v[2] = -s;
 397                                         break;
 398                                 case 1:
 399                                         v[0] = -1;
 400                                         v[1] = -t;
 401                                         v[2] = s;
 402                                         break;
 403                                 case 2:
 404                                         v[0] = s;
 405                                         v[1] = 1;
 406                                         v[2] = t;
 407                                         break;
 408                                 case 3:
 409                                         v[0] = s;
 410                                         v[1] = -1;
 411                                         v[2] = -t;
 412                                         break;
 413                                 case 4:
 414                                         v[0] = s;
 415                                         v[1] = -t;
 416                                         v[2] = 1;
 417                                         break;
 418                                 case 5:
 419                                         v[0] = -s;
 420                                         v[1] = -t;
 421                                         v[2] = -1;
 422                                         break;
 423                                 }
 424                                 intensity = 127.0f / sqrt(DotProduct(v, v));
 425                                 data[((side*64+y)*64+x)*4+2] = (unsigned char)(128.0f + intensity * v[0]);
 426                                 data[((side*64+y)*64+x)*4+1] = (unsigned char)(128.0f + intensity * v[1]);
 427                                 data[((side*64+y)*64+x)*4+0] = (unsigned char)(128.0f + intensity * v[2]);
 428                                 data[((side*64+y)*64+x)*4+3] = 255;
 429                         }
 430                 }
 431         }
 432         r_texture_normalizationcube = R_LoadTextureCubeMap(r_main_texturepool, "normalcube", NORMSIZE, data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL);
 433         Mem_Free(data);
 434 }
 435
 436 static void R_BuildFogTexture(void)
 437 {
 438         int x, b;
 439 #define FOGWIDTH 256
 440         unsigned char data1[FOGWIDTH][4];
 441         //unsigned char data2[FOGWIDTH][4];
 442         double d, r, alpha;
 443
 444         r_refdef.fogmasktable_start = r_refdef.fog_start;
 445         r_refdef.fogmasktable_alpha = r_refdef.fog_alpha;
 446         r_refdef.fogmasktable_range = r_refdef.fogrange;
 447         r_refdef.fogmasktable_density = r_refdef.fog_density;
 448
 449         r = r_refdef.fogmasktable_range / FOGMASKTABLEWIDTH;
 450         for (x = 0;x < FOGMASKTABLEWIDTH;x++)
 451         {
 452                 d = (x * r - r_refdef.fogmasktable_start);
 453                 if(developer_extra.integer)
 454                         Con_DPrintf("%f ", d);
 455                 d = max(0, d);
 456                 if (r_fog_exp2.integer)
 457                         alpha = exp(-r_refdef.fogmasktable_density * r_refdef.fogmasktable_density * 0.0001 * d * d);
 458                 else
 459                         alpha = exp(-r_refdef.fogmasktable_density * 0.004 * d);
 460                 if(developer_extra.integer)
 461                         Con_DPrintf(" : %f ", alpha);
 462                 alpha = 1 - (1 - alpha) * r_refdef.fogmasktable_alpha;
 463                 if(developer_extra.integer)
 464                         Con_DPrintf(" = %f\n", alpha);
 465                 r_refdef.fogmasktable[x] = bound(0, alpha, 1);
 466         }
 467
 468         for (x = 0;x < FOGWIDTH;x++)
 469         {
 470                 b = (int)(r_refdef.fogmasktable[x * (FOGMASKTABLEWIDTH - 1) / (FOGWIDTH - 1)] * 255);
 471                 data1[x][0] = b;
 472                 data1[x][1] = b;
 473                 data1[x][2] = b;
 474                 data1[x][3] = 255;
 475                 //data2[x][0] = 255 - b;
 476                 //data2[x][1] = 255 - b;
 477                 //data2[x][2] = 255 - b;
 478                 //data2[x][3] = 255;
 479         }
 480         if (r_texture_fogattenuation)
 481         {
 482                 R_UpdateTexture(r_texture_fogattenuation, &data1[0][0], 0, 0, FOGWIDTH, 1);
 483                 //R_UpdateTexture(r_texture_fogattenuation, &data2[0][0], 0, 0, FOGWIDTH, 1);
 484         }
 485         else
 486         {
 487                 r_texture_fogattenuation = R_LoadTexture2D(r_main_texturepool, "fogattenuation", FOGWIDTH, 1, &data1[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL);
 488                 //r_texture_fogintensity = R_LoadTexture2D(r_main_texturepool, "fogintensity", FOGWIDTH, 1, &data2[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP, NULL);
 489         }
 490 }
 491
 492 static void R_BuildFogHeightTexture(void)
 493 {
 494         unsigned char *inpixels;
 495         int size;
 496         int x;
 497         int y;
 498         int j;
 499         float c[4];
 500         float f;
 501         inpixels = NULL;
 502         strlcpy(r_refdef.fogheighttexturename, r_refdef.fog_height_texturename, sizeof(r_refdef.fogheighttexturename));
 503         if (r_refdef.fogheighttexturename[0])
 504                 inpixels = loadimagepixelsbgra(r_refdef.fogheighttexturename, true, false, false, NULL);
 505         if (!inpixels)
 506         {
 507                 r_refdef.fog_height_tablesize = 0;
 508                 if (r_texture_fogheighttexture)
 509                         R_FreeTexture(r_texture_fogheighttexture);
 510                 r_texture_fogheighttexture = NULL;
 511                 if (r_refdef.fog_height_table2d)
 512                         Mem_Free(r_refdef.fog_height_table2d);
 513                 r_refdef.fog_height_table2d = NULL;
 514                 if (r_refdef.fog_height_table1d)
 515                         Mem_Free(r_refdef.fog_height_table1d);
 516                 r_refdef.fog_height_table1d = NULL;
 517                 return;
 518         }
 519         size = image_width;
 520         r_refdef.fog_height_tablesize = size;
 521         r_refdef.fog_height_table1d = Mem_Alloc(r_main_mempool, size * 4);
 522         r_refdef.fog_height_table2d = Mem_Alloc(r_main_mempool, size * size * 4);
 523         memcpy(r_refdef.fog_height_table1d, inpixels, size * 4);
 524         Mem_Free(inpixels);
 525         // LordHavoc: now the magic - what is that table2d for?  it is a cooked
 526         // average fog color table accounting for every fog layer between a point
 527         // and the camera.  (Note: attenuation is handled separately!)
 528         for (y = 0;y < size;y++)
 529         {
 530                 for (x = 0;x < size;x++)
 531                 {
 532                         Vector4Clear(c);
 533                         f = 0;
 534                         if (x < y)
 535                         {
 536                                 for (j = x;j <= y;j++)
 537                                 {
 538                                         Vector4Add(c, r_refdef.fog_height_table1d + j*4, c);
 539                                         f++;
 540                                 }
 541                         }
 542                         else
 543                         {
 544                                 for (j = x;j >= y;j--)
 545                                 {
 546                                         Vector4Add(c, r_refdef.fog_height_table1d + j*4, c);
 547                                         f++;
 548                                 }
 549                         }
 550                         f = 1.0f / f;
 551                         r_refdef.fog_height_table2d[(y*size+x)*4+0] = (unsigned char)(c[0] * f);
 552                         r_refdef.fog_height_table2d[(y*size+x)*4+1] = (unsigned char)(c[1] * f);
 553                         r_refdef.fog_height_table2d[(y*size+x)*4+2] = (unsigned char)(c[2] * f);
 554                         r_refdef.fog_height_table2d[(y*size+x)*4+3] = (unsigned char)(c[3] * f);
 555                 }
 556         }
 557         r_texture_fogheighttexture = R_LoadTexture2D(r_main_texturepool, "fogheighttable", size, size, r_refdef.fog_height_table2d, TEXTYPE_BGRA, TEXF_ALPHA | TEXF_CLAMP, -1, NULL);
 558 }
 559
 560 //=======================================================================================================================================================
 561
 562 static const char *builtinshaderstring =
 563 "// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
 564 "// written by Forest 'LordHavoc' Hale\n"
 565 "// shadowmapping enhancements by Lee 'eihrul' Salzman\n"
 566 "\n"
 567 "#if defined(USEFOGINSIDE) || defined(USEFOGOUTSIDE) || defined(USEFOGHEIGHTTEXTURE)\n"
 568 "# define USEFOG\n"
 569 "#endif\n"
 570 "#if defined(MODE_LIGHTMAP) || defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
 571 "#define USELIGHTMAP\n"
 572 "#endif\n"
 573 "#if defined(USESPECULAR) || defined(USEOFFSETMAPPING) || defined(USEREFLECTCUBE)\n"
 574 "#define USEEYEVECTOR\n"
 575 "#endif\n"
 576 "\n"
 577 "#if defined(USESHADOWMAPRECT) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USEDEFERREDLIGHTMAP)\n"
 578 "# extension GL_ARB_texture_rectangle : enable\n"
 579 "#endif\n"
 580 "\n"
 581 "#ifdef USESHADOWMAP2D\n"
 582 "# ifdef GL_EXT_gpu_shader4\n"
 583 "#   extension GL_EXT_gpu_shader4 : enable\n"
 584 "# endif\n"
 585 "# ifdef GL_ARB_texture_gather\n"
 586 "#   extension GL_ARB_texture_gather : enable\n"
 587 "# else\n"
 588 "#   ifdef GL_AMD_texture_texture4\n"
 589 "#     extension GL_AMD_texture_texture4 : enable\n"
 590 "#   endif\n"
 591 "# endif\n"
 592 "#endif\n"
 593 "\n"
 594 "#ifdef USESHADOWMAPCUBE\n"
 595 "# extension GL_EXT_gpu_shader4 : enable\n"
 596 "#endif\n"
 597 "\n"
 598 "//#ifdef USESHADOWSAMPLER\n"
 599 "//# extension GL_ARB_shadow : enable\n"
 600 "//#endif\n"
 601 "\n"
 602 "//#ifdef __GLSL_CG_DATA_TYPES\n"
 603 "//# define myhalf half\n"
 604 "//# define myhalf2 half2\n"
 605 "//# define myhalf3 half3\n"
 606 "//# define myhalf4 half4\n"
 607 "//#else\n"
 608 "# define myhalf float\n"
 609 "# define myhalf2 vec2\n"
 610 "# define myhalf3 vec3\n"
 611 "# define myhalf4 vec4\n"
 612 "//#endif\n"
 613 "\n"
 614 "#ifdef VERTEX_SHADER\n"
 615 "uniform mat4 ModelViewProjectionMatrix;\n"
 616 "#endif\n"
 617 "\n"
 618 "#ifdef MODE_DEPTH_OR_SHADOW\n"
 619 "#ifdef VERTEX_SHADER\n"
 620 "void main(void)\n"
 621 "{\n"
 622 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 623 "}\n"
 624 "#endif\n"
 625 "#else // !MODE_DEPTH_ORSHADOW\n"
 626 "\n"
 627 "\n"
 628 "\n"
 629 "\n"
 630 "#ifdef MODE_SHOWDEPTH\n"
 631 "#ifdef VERTEX_SHADER\n"
 632 "void main(void)\n"
 633 "{\n"
 634 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 635 "       gl_FrontColor = vec4(gl_Position.z, gl_Position.z, gl_Position.z, 1.0);\n"
 636 "}\n"
 637 "#endif\n"
 638 "\n"
 639 "#ifdef FRAGMENT_SHADER\n"
 640 "void main(void)\n"
 641 "{\n"
 642 "       gl_FragColor = gl_Color;\n"
 643 "}\n"
 644 "#endif\n"
 645 "#else // !MODE_SHOWDEPTH\n"
 646 "\n"
 647 "\n"
 648 "\n"
 649 "\n"
 650 "#ifdef MODE_POSTPROCESS\n"
 651 "varying vec2 TexCoord1;\n"
 652 "varying vec2 TexCoord2;\n"
 653 "\n"
 654 "#ifdef VERTEX_SHADER\n"
 655 "void main(void)\n"
 656 "{\n"
 657 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 658 "       TexCoord1 = gl_MultiTexCoord0.xy;\n"
 659 "#ifdef USEBLOOM\n"
 660 "       TexCoord2 = gl_MultiTexCoord1.xy;\n"
 661 "#endif\n"
 662 "}\n"
 663 "#endif\n"
 664 "\n"
 665 "#ifdef FRAGMENT_SHADER\n"
 666 "uniform sampler2D Texture_First;\n"
 667 "#ifdef USEBLOOM\n"
 668 "uniform sampler2D Texture_Second;\n"
 669 "#endif\n"
 670 "#ifdef USEGAMMARAMPS\n"
 671 "uniform sampler2D Texture_GammaRamps;\n"
 672 "#endif\n"
 673 "#ifdef USESATURATION\n"
 674 "uniform float Saturation;\n"
 675 "#endif\n"
 676 "#ifdef USEVIEWTINT\n"
 677 "uniform vec4 ViewTintColor;\n"
 678 "#endif\n"
 679 "//uncomment these if you want to use them:\n"
 680 "uniform vec4 UserVec1;\n"
 681 "uniform vec4 UserVec2;\n"
 682 "// uniform vec4 UserVec3;\n"
 683 "// uniform vec4 UserVec4;\n"
 684 "// uniform float ClientTime;\n"
 685 "uniform vec2 PixelSize;\n"
 686 "void main(void)\n"
 687 "{\n"
 688 "       gl_FragColor = texture2D(Texture_First, TexCoord1);\n"
 689 "#ifdef USEBLOOM\n"
 690 "       gl_FragColor += texture2D(Texture_Second, TexCoord2);\n"
 691 "#endif\n"
 692 "#ifdef USEVIEWTINT\n"
 693 "       gl_FragColor = mix(gl_FragColor, ViewTintColor, ViewTintColor.a);\n"
 694 "#endif\n"
 695 "\n"
 696 "#ifdef USEPOSTPROCESSING\n"
 697 "// do r_glsl_dumpshader, edit glsl/default.glsl, and replace this by your own postprocessing if you want\n"
 698 "// this code does a blur with the radius specified in the first component of r_glsl_postprocess_uservec1 and blends it using the second component\n"
 699 "       float sobel = 1.0;\n"
 700 "       // vec2 ts = textureSize(Texture_First, 0);\n"
 701 "       // vec2 px = vec2(1/ts.x, 1/ts.y);\n"
 702 "       vec2 px = PixelSize;\n"
 703 "       vec3 x1 = texture2D(Texture_First, TexCoord1 + vec2(-px.x, px.y)).rgb;\n"
 704 "       vec3 x2 = texture2D(Texture_First, TexCoord1 + vec2(-px.x,  0.0)).rgb;\n"
 705 "       vec3 x3 = texture2D(Texture_First, TexCoord1 + vec2(-px.x,-px.y)).rgb;\n"
 706 "       vec3 x4 = texture2D(Texture_First, TexCoord1 + vec2( px.x, px.y)).rgb;\n"
 707 "       vec3 x5 = texture2D(Texture_First, TexCoord1 + vec2( px.x,  0.0)).rgb;\n"
 708 "       vec3 x6 = texture2D(Texture_First, TexCoord1 + vec2( px.x,-px.y)).rgb;\n"
 709 "       vec3 y1 = texture2D(Texture_First, TexCoord1 + vec2( px.x,-px.y)).rgb;\n"
 710 "       vec3 y2 = texture2D(Texture_First, TexCoord1 + vec2(  0.0,-px.y)).rgb;\n"
 711 "       vec3 y3 = texture2D(Texture_First, TexCoord1 + vec2(-px.x,-px.y)).rgb;\n"
 712 "       vec3 y4 = texture2D(Texture_First, TexCoord1 + vec2( px.x, px.y)).rgb;\n"
 713 "       vec3 y5 = texture2D(Texture_First, TexCoord1 + vec2(  0.0, px.y)).rgb;\n"
 714 "       vec3 y6 = texture2D(Texture_First, TexCoord1 + vec2(-px.x, px.y)).rgb;\n"
 715 "       float px1 = -1.0 * dot(vec3(0.3, 0.59, 0.11), x1);\n"
 716 "       float px2 = -2.0 * dot(vec3(0.3, 0.59, 0.11), x2);\n"
 717 "       float px3 = -1.0 * dot(vec3(0.3, 0.59, 0.11), x3);\n"
 718 "       float px4 =  1.0 * dot(vec3(0.3, 0.59, 0.11), x4);\n"
 719 "       float px5 =  2.0 * dot(vec3(0.3, 0.59, 0.11), x5);\n"
 720 "       float px6 =  1.0 * dot(vec3(0.3, 0.59, 0.11), x6);\n"
 721 "       float py1 = -1.0 * dot(vec3(0.3, 0.59, 0.11), y1);\n"
 722 "       float py2 = -2.0 * dot(vec3(0.3, 0.59, 0.11), y2);\n"
 723 "       float py3 = -1.0 * dot(vec3(0.3, 0.59, 0.11), y3);\n"
 724 "       float py4 =  1.0 * dot(vec3(0.3, 0.59, 0.11), y4);\n"
 725 "       float py5 =  2.0 * dot(vec3(0.3, 0.59, 0.11), y5);\n"
 726 "       float py6 =  1.0 * dot(vec3(0.3, 0.59, 0.11), y6);\n"
 727 "       sobel = 0.25 * abs(px1 + px2 + px3 + px4 + px5 + px6) + 0.25 * abs(py1 + py2 + py3 + py4 + py5 + py6);\n"
 728 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2(-0.987688, -0.156434)) * UserVec1.y;\n"
 729 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2(-0.156434, -0.891007)) * UserVec1.y;\n"
 730 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2( 0.891007, -0.453990)) * UserVec1.y;\n"
 731 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2( 0.707107,  0.707107)) * UserVec1.y;\n"
 732 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2(-0.453990,  0.891007)) * UserVec1.y;\n"
 733 "       gl_FragColor /= (1.0 + 5.0 * UserVec1.y);\n"
 734 "       gl_FragColor.rgb = gl_FragColor.rgb * (1.0 + UserVec2.x) + vec3(max(0.0, sobel - UserVec2.z))*UserVec2.y;\n"
 735 "#endif\n"
 736 "\n"
 737 "#ifdef USESATURATION\n"
 738 "       //apply saturation BEFORE gamma ramps, so v_glslgamma value does not matter\n"
 739 "       float y = dot(gl_FragColor.rgb, vec3(0.299, 0.587, 0.114));\n"
 740 "       //gl_FragColor = vec3(y) + (gl_FragColor.rgb - vec3(y)) * Saturation;\n"
 741 "       gl_FragColor.rgb = mix(vec3(y), gl_FragColor.rgb, Saturation);\n"
 742 "#endif\n"
 743 "\n"
 744 "#ifdef USEGAMMARAMPS\n"
 745 "       gl_FragColor.r = texture2D(Texture_GammaRamps, vec2(gl_FragColor.r, 0)).r;\n"
 746 "       gl_FragColor.g = texture2D(Texture_GammaRamps, vec2(gl_FragColor.g, 0)).g;\n"
 747 "       gl_FragColor.b = texture2D(Texture_GammaRamps, vec2(gl_FragColor.b, 0)).b;\n"
 748 "#endif\n"
 749 "}\n"
 750 "#endif\n"
 751 "#else // !MODE_POSTPROCESS\n"
 752 "\n"
 753 "\n"
 754 "\n"
 755 "\n"
 756 "#ifdef MODE_GENERIC\n"
 757 "#ifdef USEDIFFUSE\n"
 758 "varying vec2 TexCoord1;\n"
 759 "#endif\n"
 760 "#ifdef USESPECULAR\n"
 761 "varying vec2 TexCoord2;\n"
 762 "#endif\n"
 763 "#ifdef VERTEX_SHADER\n"
 764 "void main(void)\n"
 765 "{\n"
 766 "       gl_FrontColor = gl_Color;\n"
 767 "#ifdef USEDIFFUSE\n"
 768 "       TexCoord1 = gl_MultiTexCoord0.xy;\n"
 769 "#endif\n"
 770 "#ifdef USESPECULAR\n"
 771 "       TexCoord2 = gl_MultiTexCoord1.xy;\n"
 772 "#endif\n"
 773 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 774 "}\n"
 775 "#endif\n"
 776 "\n"
 777 "#ifdef FRAGMENT_SHADER\n"
 778 "#ifdef USEDIFFUSE\n"
 779 "uniform sampler2D Texture_First;\n"
 780 "#endif\n"
 781 "#ifdef USESPECULAR\n"
 782 "uniform sampler2D Texture_Second;\n"
 783 "#endif\n"
 784 "\n"
 785 "void main(void)\n"
 786 "{\n"
 787 "       gl_FragColor = gl_Color;\n"
 788 "#ifdef USEDIFFUSE\n"
 789 "       gl_FragColor *= texture2D(Texture_First, TexCoord1);\n"
 790 "#endif\n"
 791 "\n"
 792 "#ifdef USESPECULAR\n"
 793 "       vec4 tex2 = texture2D(Texture_Second, TexCoord2);\n"
 794 "# ifdef USECOLORMAPPING\n"
 795 "       gl_FragColor *= tex2;\n"
 796 "# endif\n"
 797 "# ifdef USEGLOW\n"
 798 "       gl_FragColor += tex2;\n"
 799 "# endif\n"
 800 "# ifdef USEVERTEXTEXTUREBLEND\n"
 801 "       gl_FragColor = mix(gl_FragColor, tex2, tex2.a);\n"
 802 "# endif\n"
 803 "#endif\n"
 804 "}\n"
 805 "#endif\n"
 806 "#else // !MODE_GENERIC\n"
 807 "\n"
 808 "\n"
 809 "\n"
 810 "\n"
 811 "#ifdef MODE_BLOOMBLUR\n"
 812 "varying TexCoord;\n"
 813 "#ifdef VERTEX_SHADER\n"
 814 "void main(void)\n"
 815 "{\n"
 816 "       gl_FrontColor = gl_Color;\n"
 817 "       TexCoord = gl_MultiTexCoord0.xy;\n"
 818 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 819 "}\n"
 820 "#endif\n"
 821 "\n"
 822 "#ifdef FRAGMENT_SHADER\n"
 823 "uniform sampler2D Texture_First;\n"
 824 "uniform vec4 BloomBlur_Parameters;\n"
 825 "\n"
 826 "void main(void)\n"
 827 "{\n"
 828 "       int i;\n"
 829 "       vec2 tc = TexCoord;\n"
 830 "       vec3 color = texture2D(Texture_First, tc).rgb;\n"
 831 "       tc += BloomBlur_Parameters.xy;\n"
 832 "       for (i = 1;i < SAMPLES;i++)\n"
 833 "       {\n"
 834 "               color += texture2D(Texture_First, tc).rgb;\n"
 835 "               tc += BloomBlur_Parameters.xy;\n"
 836 "       }\n"
 837 "       gl_FragColor = vec4(color * BloomBlur_Parameters.z + vec3(BloomBlur_Parameters.w), 1);\n"
 838 "}\n"
 839 "#endif\n"
 840 "#else // !MODE_BLOOMBLUR\n"
 841 "#ifdef MODE_REFRACTION\n"
 842 "varying vec2 TexCoord;\n"
 843 "varying vec4 ModelViewProjectionPosition;\n"
 844 "uniform mat4 TexMatrix;\n"
 845 "#ifdef VERTEX_SHADER\n"
 846 "\n"
 847 "void main(void)\n"
 848 "{\n"
 849 "       TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
 850 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 851 "       ModelViewProjectionPosition = gl_Position;\n"
 852 "}\n"
 853 "#endif\n"
 854 "\n"
 855 "#ifdef FRAGMENT_SHADER\n"
 856 "uniform sampler2D Texture_Normal;\n"
 857 "uniform sampler2D Texture_Refraction;\n"
 858 "uniform sampler2D Texture_Reflection;\n"
 859 "\n"
 860 "uniform vec4 DistortScaleRefractReflect;\n"
 861 "uniform vec4 ScreenScaleRefractReflect;\n"
 862 "uniform vec4 ScreenCenterRefractReflect;\n"
 863 "uniform vec4 RefractColor;\n"
 864 "uniform vec4 ReflectColor;\n"
 865 "uniform float ReflectFactor;\n"
 866 "uniform float ReflectOffset;\n"
 867 "\n"
 868 "void main(void)\n"
 869 "{\n"
 870 "       vec2 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect.xy * (1.0 / ModelViewProjectionPosition.w);\n"
 871 "       //vec2 ScreenTexCoord = (ModelViewProjectionPosition.xy + normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5)).xy * DistortScaleRefractReflect.xy * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
 872 "       vec2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
 873 "       vec2 ScreenTexCoord = SafeScreenTexCoord + vec2(normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5))).xy * DistortScaleRefractReflect.xy;\n"
 874 "       // FIXME temporary hack to detect the case that the reflection\n"
 875 "       // gets blackened at edges due to leaving the area that contains actual\n"
 876 "       // content.\n"
 877 "       // Remove this 'ack once we have a better way to stop this thing from\n"
 878 "       // 'appening.\n"
 879 "       float f = min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(0.01, 0.01)).rgb) / 0.05);\n"
 880 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(0.01, -0.01)).rgb) / 0.05);\n"
 881 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
 882 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
 883 "       ScreenTexCoord = mix(SafeScreenTexCoord, ScreenTexCoord, f);\n"
 884 "       gl_FragColor = texture2D(Texture_Refraction, ScreenTexCoord) * RefractColor;\n"
 885 "}\n"
 886 "#endif\n"
 887 "#else // !MODE_REFRACTION\n"
 888 "\n"
 889 "\n"
 890 "\n"
 891 "\n"
 892 "#ifdef MODE_WATER\n"
 893 "varying vec2 TexCoord;\n"
 894 "varying vec3 EyeVector;\n"
 895 "varying vec4 ModelViewProjectionPosition;\n"
 896 "#ifdef VERTEX_SHADER\n"
 897 "uniform vec3 EyePosition;\n"
 898 "uniform mat4 TexMatrix;\n"
 899 "\n"
 900 "void main(void)\n"
 901 "{\n"
 902 "       TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
 903 "       vec3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
 904 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
 905 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
 906 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
 907 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 908 "       ModelViewProjectionPosition = gl_Position;\n"
 909 "}\n"
 910 "#endif\n"
 911 "\n"
 912 "#ifdef FRAGMENT_SHADER\n"
 913 "uniform sampler2D Texture_Normal;\n"
 914 "uniform sampler2D Texture_Refraction;\n"
 915 "uniform sampler2D Texture_Reflection;\n"
 916 "\n"
 917 "uniform vec4 DistortScaleRefractReflect;\n"
 918 "uniform vec4 ScreenScaleRefractReflect;\n"
 919 "uniform vec4 ScreenCenterRefractReflect;\n"
 920 "uniform vec4 RefractColor;\n"
 921 "uniform vec4 ReflectColor;\n"
 922 "uniform float ReflectFactor;\n"
 923 "uniform float ReflectOffset;\n"
 924 "\n"
 925 "void main(void)\n"
 926 "{\n"
 927 "       vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
 928 "       //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
 929 "       vec4 SafeScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
 930 "       //SafeScreenTexCoord = gl_FragCoord.xyxy * vec4(1.0 / 1920.0, 1.0 / 1200.0, 1.0 / 1920.0, 1.0 / 1200.0);\n"
 931 "       vec4 ScreenTexCoord = SafeScreenTexCoord + vec2(normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5))).xyxy * DistortScaleRefractReflect;\n"
 932 "       // FIXME temporary hack to detect the case that the reflection\n"
 933 "       // gets blackened at edges due to leaving the area that contains actual\n"
 934 "       // content.\n"
 935 "       // Remove this 'ack once we have a better way to stop this thing from\n"
 936 "       // 'appening.\n"
 937 "       float f = min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(0.01, 0.01)).rgb) / 0.05);\n"
 938 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(0.01, -0.01)).rgb) / 0.05);\n"
 939 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
 940 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
 941 "       ScreenTexCoord.xy = mix(SafeScreenTexCoord.xy, ScreenTexCoord.xy, f);\n"
 942 "       f       = min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(0.01, 0.01)).rgb) / 0.05);\n"
 943 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(0.01, -0.01)).rgb) / 0.05);\n"
 944 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
 945 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
 946 "       ScreenTexCoord.zw = mix(SafeScreenTexCoord.zw, ScreenTexCoord.zw, f);\n"
 947 "       float Fresnel = pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 2.0) * ReflectFactor + ReflectOffset;\n"
 948 "       gl_FragColor = mix(texture2D(Texture_Refraction, ScreenTexCoord.xy) * RefractColor, texture2D(Texture_Reflection, ScreenTexCoord.zw) * ReflectColor, Fresnel);\n"
 949 "}\n"
 950 "#endif\n"
 951 "#else // !MODE_WATER\n"
 952 "\n"
 953 "\n"
 954 "\n"
 955 "\n"
 956 "// common definitions between vertex shader and fragment shader:\n"
 957 "\n"
 958 "varying vec2 TexCoord;\n"
 959 "#ifdef USEVERTEXTEXTUREBLEND\n"
 960 "varying vec2 TexCoord2;\n"
 961 "#endif\n"
 962 "#ifdef USELIGHTMAP\n"
 963 "varying vec2 TexCoordLightmap;\n"
 964 "#endif\n"
 965 "\n"
 966 "#ifdef MODE_LIGHTSOURCE\n"
 967 "varying vec3 CubeVector;\n"
 968 "#endif\n"
 969 "\n"
 970 "#if (defined(MODE_LIGHTSOURCE) || defined(MODE_LIGHTDIRECTION)) && defined(USEDIFFUSE)\n"
 971 "varying vec3 LightVector;\n"
 972 "#endif\n"
 973 "\n"
 974 "#ifdef USEEYEVECTOR\n"
 975 "varying vec3 EyeVector;\n"
 976 "#endif\n"
 977 "#ifdef USEFOG\n"
 978 "varying vec4 EyeVectorModelSpaceFogPlaneVertexDist;\n"
 979 "#endif\n"
 980 "\n"
 981 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY) || defined(USEREFLECTCUBE)\n"
 982 "varying vec3 VectorS; // direction of S texcoord (sometimes crudely called tangent)\n"
 983 "varying vec3 VectorT; // direction of T texcoord (sometimes crudely called binormal)\n"
 984 "varying vec3 VectorR; // direction of R texcoord (surface normal)\n"
 985 "#endif\n"
 986 "\n"
 987 "#ifdef USEREFLECTION\n"
 988 "varying vec4 ModelViewProjectionPosition;\n"
 989 "#endif\n"
 990 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
 991 "uniform vec3 LightPosition;\n"
 992 "varying vec4 ModelViewPosition;\n"
 993 "#endif\n"
 994 "\n"
 995 "#ifdef MODE_LIGHTSOURCE\n"
 996 "uniform vec3 LightPosition;\n"
 997 "#endif\n"
 998 "uniform vec3 EyePosition;\n"
 999 "#ifdef MODE_LIGHTDIRECTION\n"
1000 "uniform vec3 LightDir;\n"
1001 "#endif\n"
1002 "uniform vec4 FogPlane;\n"
1003 "\n"
1004 "#ifdef USESHADOWMAPORTHO\n"
1005 "varying vec3 ShadowMapTC;\n"
1006 "#endif\n"
1007 "\n"
1008 "\n"
1009 "\n"
1010 "\n"
1011 "\n"
1012 "// TODO: get rid of tangentt (texcoord2) and use a crossproduct to regenerate it from tangents (texcoord1) and normal (texcoord3), this would require sending a 4 component texcoord1 with W as 1 or -1 according to which side the texcoord2 should be on\n"
1013 "\n"
1014 "// fragment shader specific:\n"
1015 "#ifdef FRAGMENT_SHADER\n"
1016 "\n"
1017 "uniform sampler2D Texture_Normal;\n"
1018 "uniform sampler2D Texture_Color;\n"
1019 "uniform sampler2D Texture_Gloss;\n"
1020 "#ifdef USEGLOW\n"
1021 "uniform sampler2D Texture_Glow;\n"
1022 "#endif\n"
1023 "#ifdef USEVERTEXTEXTUREBLEND\n"
1024 "uniform sampler2D Texture_SecondaryNormal;\n"
1025 "uniform sampler2D Texture_SecondaryColor;\n"
1026 "uniform sampler2D Texture_SecondaryGloss;\n"
1027 "#ifdef USEGLOW\n"
1028 "uniform sampler2D Texture_SecondaryGlow;\n"
1029 "#endif\n"
1030 "#endif\n"
1031 "#ifdef USECOLORMAPPING\n"
1032 "uniform sampler2D Texture_Pants;\n"
1033 "uniform sampler2D Texture_Shirt;\n"
1034 "#endif\n"
1035 "#ifdef USEFOG\n"
1036 "#ifdef USEFOGHEIGHTTEXTURE\n"
1037 "uniform sampler2D Texture_FogHeightTexture;\n"
1038 "#endif\n"
1039 "uniform sampler2D Texture_FogMask;\n"
1040 "#endif\n"
1041 "#ifdef USELIGHTMAP\n"
1042 "uniform sampler2D Texture_Lightmap;\n"
1043 "#endif\n"
1044 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
1045 "uniform sampler2D Texture_Deluxemap;\n"
1046 "#endif\n"
1047 "#ifdef USEREFLECTION\n"
1048 "uniform sampler2D Texture_Reflection;\n"
1049 "#endif\n"
1050 "\n"
1051 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
1052 "uniform sampler2D Texture_ScreenDepth;\n"
1053 "uniform sampler2D Texture_ScreenNormalMap;\n"
1054 "#endif\n"
1055 "#ifdef USEDEFERREDLIGHTMAP\n"
1056 "uniform sampler2D Texture_ScreenDiffuse;\n"
1057 "uniform sampler2D Texture_ScreenSpecular;\n"
1058 "#endif\n"
1059 "\n"
1060 "uniform myhalf3 Color_Pants;\n"
1061 "uniform myhalf3 Color_Shirt;\n"
1062 "uniform myhalf3 FogColor;\n"
1063 "\n"
1064 "#ifdef USEFOG\n"
1065 "uniform float FogRangeRecip;\n"
1066 "uniform float FogPlaneViewDist;\n"
1067 "uniform float FogHeightFade;\n"
1068 "vec3 FogVertex(vec3 surfacecolor)\n"
1069 "{\n"
1070 "       vec3 EyeVectorModelSpace = EyeVectorModelSpaceFogPlaneVertexDist.xyz;\n"
1071 "       float FogPlaneVertexDist = EyeVectorModelSpaceFogPlaneVertexDist.w;\n"
1072 "       float fogfrac;\n"
1073 "#ifdef USEFOGHEIGHTTEXTURE\n"
1074 "       vec4 fogheightpixel = texture2D(Texture_FogHeightTexture, vec2(1,1) + vec2(FogPlaneVertexDist, FogPlaneViewDist) * (-2.0 * FogHeightFade));\n"
1075 "       fogfrac = fogheightpixel.a;\n"
1076 "       return mix(fogheightpixel.rgb * FogColor, surfacecolor, texture2D(Texture_FogMask, myhalf2(length(EyeVectorModelSpace)*fogfrac*FogRangeRecip, 0.0)).r);\n"
1077 "#else\n"
1078 "# ifdef USEFOGOUTSIDE\n"
1079 "       fogfrac = min(0.0, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0, min(0.0, FogPlaneVertexDist) * FogHeightFade);\n"
1080 "# else\n"
1081 "       fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0, FogPlaneVertexDist)) * min(1.0, (min(0.0, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);\n"
1082 "# endif\n"
1083 "       return mix(FogColor, surfacecolor, texture2D(Texture_FogMask, myhalf2(length(EyeVectorModelSpace)*fogfrac*FogRangeRecip, 0.0)).r);\n"
1084 "#endif\n"
1085 "}\n"
1086 "#endif\n"
1087 "\n"
1088 "#ifdef USEOFFSETMAPPING\n"
1089 "uniform float OffsetMapping_Scale;\n"
1090 "vec2 OffsetMapping(vec2 TexCoord)\n"
1091 "{\n"
1092 "#ifdef USEOFFSETMAPPING_RELIEFMAPPING\n"
1093 "       // 14 sample relief mapping: linear search and then binary search\n"
1094 "       // this basically steps forward a small amount repeatedly until it finds\n"
1095 "       // itself inside solid, then jitters forward and back using decreasing\n"
1096 "       // amounts to find the impact\n"
1097 "       //vec3 OffsetVector = vec3(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1), -1);\n"
1098 "       //vec3 OffsetVector = vec3(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
1099 "       vec3 OffsetVector = vec3(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
1100 "       vec3 RT = vec3(TexCoord, 1);\n"
1101 "       OffsetVector *= 0.1;\n"
1102 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1103 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1104 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1105 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1106 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1107 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1108 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1109 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1110 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1111 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z)          - 0.5);\n"
1112 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.5    - 0.25);\n"
1113 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.25   - 0.125);\n"
1114 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.125  - 0.0625);\n"
1115 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.0625 - 0.03125);\n"
1116 "       return RT.xy;\n"
1117 "#else\n"
1118 "       // 3 sample offset mapping (only 3 samples because of ATI Radeon 9500-9800/X300 limits)\n"
1119 "       // this basically moves forward the full distance, and then backs up based\n"
1120 "       // on height of samples\n"
1121 "       //vec2 OffsetVector = vec2(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1));\n"
1122 "       //vec2 OffsetVector = vec2(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1));\n"
1123 "       vec2 OffsetVector = vec2(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1));\n"
1124 "       TexCoord += OffsetVector;\n"
1125 "       OffsetVector *= 0.333;\n"
1126 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
1127 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
1128 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
1129 "       return TexCoord;\n"
1130 "#endif\n"
1131 "}\n"
1132 "#endif // USEOFFSETMAPPING\n"
1133 "\n"
1134 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE)\n"
1135 "uniform sampler2D Texture_Attenuation;\n"
1136 "uniform samplerCube Texture_Cube;\n"
1137 "#endif\n"
1138 "\n"
1139 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USESHADOWMAPORTHO)\n"
1140 "\n"
1141 "#ifdef USESHADOWMAPRECT\n"
1142 "# ifdef USESHADOWSAMPLER\n"
1143 "uniform sampler2DRectShadow Texture_ShadowMapRect;\n"
1144 "# else\n"
1145 "uniform sampler2DRect Texture_ShadowMapRect;\n"
1146 "# endif\n"
1147 "#endif\n"
1148 "\n"
1149 "#ifdef USESHADOWMAP2D\n"
1150 "# ifdef USESHADOWSAMPLER\n"
1151 "uniform sampler2DShadow Texture_ShadowMap2D;\n"
1152 "# else\n"
1153 "uniform sampler2D Texture_ShadowMap2D;\n"
1154 "# endif\n"
1155 "#endif\n"
1156 "\n"
1157 "#ifdef USESHADOWMAPVSDCT\n"
1158 "uniform samplerCube Texture_CubeProjection;\n"
1159 "#endif\n"
1160 "\n"
1161 "#ifdef USESHADOWMAPCUBE\n"
1162 "# ifdef USESHADOWSAMPLER\n"
1163 "uniform samplerCubeShadow Texture_ShadowMapCube;\n"
1164 "# else\n"
1165 "uniform samplerCube Texture_ShadowMapCube;\n"
1166 "# endif\n"
1167 "#endif\n"
1168 "\n"
1169 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D) || defined(USESHADOWMAPCUBE)\n"
1170 "uniform vec2 ShadowMap_TextureScale;\n"
1171 "uniform vec4 ShadowMap_Parameters;\n"
1172 "#endif\n"
1173 "\n"
1174 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D)\n"
1175 "# ifdef USESHADOWMAPORTHO\n"
1176 "#  define GetShadowMapTC2D(dir) (min(dir, ShadowMap_Parameters.xyz))\n"
1177 "# else\n"
1178 "#  ifdef USESHADOWMAPVSDCT\n"
1179 "vec3 GetShadowMapTC2D(vec3 dir)\n"
1180 "{\n"
1181 "       vec3 adir = abs(dir);\n"
1182 "       vec2 aparams = ShadowMap_Parameters.xy / max(max(adir.x, adir.y), adir.z);\n"
1183 "       vec4 proj = textureCube(Texture_CubeProjection, dir);\n"
1184 "       return vec3(mix(dir.xy, dir.zz, proj.xy) * aparams.x + proj.zw * ShadowMap_Parameters.z, aparams.y + ShadowMap_Parameters.w);\n"
1185 "}\n"
1186 "#  else\n"
1187 "vec3 GetShadowMapTC2D(vec3 dir)\n"
1188 "{\n"
1189 "       vec3 adir = abs(dir);\n"
1190 "       float ma = adir.z;\n"
1191 "       vec4 proj = vec4(dir, 2.5);\n"
1192 "       if (adir.x > ma) { ma = adir.x; proj = vec4(dir.zyx, 0.5); }\n"
1193 "       if (adir.y > ma) { ma = adir.y; proj = vec4(dir.xzy, 1.5); }\n"
1194 "       vec2 aparams = ShadowMap_Parameters.xy / ma;\n"
1195 "       return vec3(proj.xy * aparams.x + vec2(proj.z < 0.0 ? 1.5 : 0.5, proj.w) * ShadowMap_Parameters.z, aparams.y + ShadowMap_Parameters.w);\n"
1196 "}\n"
1197 "#  endif\n"
1198 "# endif\n"
1199 "#endif // defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D)\n"
1200 "\n"
1201 "#ifdef USESHADOWMAPCUBE\n"
1202 "vec4 GetShadowMapTCCube(vec3 dir)\n"
1203 "{\n"
1204 "       vec3 adir = abs(dir);\n"
1205 "       return vec4(dir, ShadowMap_Parameters.w + ShadowMap_Parameters.y / max(max(adir.x, adir.y), adir.z));\n"
1206 "}\n"
1207 "#endif\n"
1208 "\n"
1209 "# ifdef USESHADOWMAPRECT\n"
1210 "float ShadowMapCompare(vec3 dir)\n"
1211 "{\n"
1212 "       vec3 shadowmaptc = GetShadowMapTC2D(dir);\n"
1213 "       float f;\n"
1214 "#  ifdef USESHADOWSAMPLER\n"
1215 "\n"
1216 "#    ifdef USESHADOWMAPPCF\n"
1217 "#      define texval(x, y) shadow2DRect(Texture_ShadowMapRect, shadowmaptc + vec3(x, y, 0.0)).r\n"
1218 "       f = dot(vec4(0.25), vec4(texval(-0.4, 1.0), texval(-1.0, -0.4), texval(0.4, -1.0), texval(1.0, 0.4)));\n"
1219 "#    else\n"
1220 "       f = shadow2DRect(Texture_ShadowMapRect, shadowmaptc).r;\n"
1221 "#    endif\n"
1222 "\n"
1223 "#  else\n"
1224 "\n"
1225 "#    ifdef USESHADOWMAPPCF\n"
1226 "#      if USESHADOWMAPPCF > 1\n"
1227 "#        define texval(x, y) texture2DRect(Texture_ShadowMapRect, center + vec2(x, y)).r\n"
1228 "       vec2 center = shadowmaptc.xy - 0.5, offset = fract(center);\n"
1229 "       vec4 row1 = step(shadowmaptc.z, vec4(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0), texval( 2.0, -1.0)));\n"
1230 "       vec4 row2 = step(shadowmaptc.z, vec4(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0), texval( 2.0,  0.0)));\n"
1231 "       vec4 row3 = step(shadowmaptc.z, vec4(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0), texval( 2.0,  1.0)));\n"
1232 "       vec4 row4 = step(shadowmaptc.z, vec4(texval(-1.0,  2.0), texval( 0.0,  2.0), texval( 1.0,  2.0), texval( 2.0,  2.0)));\n"
1233 "       vec4 cols = row2 + row3 + mix(row1, row4, offset.y);\n"
1234 "       f = dot(mix(cols.xyz, cols.yzw, offset.x), vec3(1.0/9.0));\n"
1235 "#      else\n"
1236 "#        define texval(x, y) texture2DRect(Texture_ShadowMapRect, shadowmaptc.xy + vec2(x, y)).r\n"
1237 "       vec2 offset = fract(shadowmaptc.xy);\n"
1238 "       vec3 row1 = step(shadowmaptc.z, vec3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n"
1239 "       vec3 row2 = step(shadowmaptc.z, vec3(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0)));\n"
1240 "       vec3 row3 = step(shadowmaptc.z, vec3(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0)));\n"
1241 "       vec3 cols = row2 + mix(row1, row3, offset.y);\n"
1242 "       f = dot(mix(cols.xy, cols.yz, offset.x), vec2(0.25));\n"
1243 "#      endif\n"
1244 "#    else\n"
1245 "       f = step(shadowmaptc.z, texture2DRect(Texture_ShadowMapRect, shadowmaptc.xy).r);\n"
1246 "#    endif\n"
1247 "\n"
1248 "#  endif\n"
1249 "#  ifdef USESHADOWMAPORTHO\n"
1250 "       return mix(ShadowMap_Parameters.w, 1.0, f);\n"
1251 "#  else\n"
1252 "       return f;\n"
1253 "#  endif\n"
1254 "}\n"
1255 "# endif\n"
1256 "\n"
1257 "# ifdef USESHADOWMAP2D\n"
1258 "float ShadowMapCompare(vec3 dir)\n"
1259 "{\n"
1260 "       vec3 shadowmaptc = GetShadowMapTC2D(dir);\n"
1261 "       float f;\n"
1262 "\n"
1263 "#  ifdef USESHADOWSAMPLER\n"
1264 "#    ifdef USESHADOWMAPPCF\n"
1265 "#      define texval(x, y) shadow2D(Texture_ShadowMap2D, vec3(center + vec2(x, y)*ShadowMap_TextureScale, shadowmaptc.z)).r  \n"
1266 "       vec2 center = shadowmaptc.xy*ShadowMap_TextureScale;\n"
1267 "       f = dot(vec4(0.25), vec4(texval(-0.4, 1.0), texval(-1.0, -0.4), texval(0.4, -1.0), texval(1.0, 0.4)));\n"
1268 "#    else\n"
1269 "       f = shadow2D(Texture_ShadowMap2D, vec3(shadowmaptc.xy*ShadowMap_TextureScale, shadowmaptc.z)).r;\n"
1270 "#    endif\n"
1271 "#  else\n"
1272 "#    ifdef USESHADOWMAPPCF\n"
1273 "#     if defined(GL_ARB_texture_gather) || defined(GL_AMD_texture_texture4)\n"
1274 "#      ifdef GL_ARB_texture_gather\n"
1275 "#        define texval(x, y) textureGatherOffset(Texture_ShadowMap2D, center, ivec2(x, y))\n"
1276 "#      else\n"
1277 "#        define texval(x, y) texture4(Texture_ShadowMap2D, center + vec2(x, y)*ShadowMap_TextureScale)\n"
1278 "#      endif\n"
1279 "       vec2 offset = fract(shadowmaptc.xy - 0.5), center = (shadowmaptc.xy - offset)*ShadowMap_TextureScale;\n"
1280 "#      if USESHADOWMAPPCF > 1\n"
1281 "   vec4 group1 = step(shadowmaptc.z, texval(-2.0, -2.0));\n"
1282 "   vec4 group2 = step(shadowmaptc.z, texval( 0.0, -2.0));\n"
1283 "   vec4 group3 = step(shadowmaptc.z, texval( 2.0, -2.0));\n"
1284 "   vec4 group4 = step(shadowmaptc.z, texval(-2.0,  0.0));\n"
1285 "   vec4 group5 = step(shadowmaptc.z, texval( 0.0,  0.0));\n"
1286 "   vec4 group6 = step(shadowmaptc.z, texval( 2.0,  0.0));\n"
1287 "   vec4 group7 = step(shadowmaptc.z, texval(-2.0,  2.0));\n"
1288 "   vec4 group8 = step(shadowmaptc.z, texval( 0.0,  2.0));\n"
1289 "   vec4 group9 = step(shadowmaptc.z, texval( 2.0,  2.0));\n"
1290 "       vec4 locols = vec4(group1.ab, group3.ab);\n"
1291 "       vec4 hicols = vec4(group7.rg, group9.rg);\n"
1292 "       locols.yz += group2.ab;\n"
1293 "       hicols.yz += group8.rg;\n"
1294 "       vec4 midcols = vec4(group1.rg, group3.rg) + vec4(group7.ab, group9.ab) +\n"
1295 "                               vec4(group4.rg, group6.rg) + vec4(group4.ab, group6.ab) +\n"
1296 "                               mix(locols, hicols, offset.y);\n"
1297 "       vec4 cols = group5 + vec4(group2.rg, group8.ab);\n"
1298 "       cols.xyz += mix(midcols.xyz, midcols.yzw, offset.x);\n"
1299 "       f = dot(cols, vec4(1.0/25.0));\n"
1300 "#      else\n"
1301 "       vec4 group1 = step(shadowmaptc.z, texval(-1.0, -1.0));\n"
1302 "       vec4 group2 = step(shadowmaptc.z, texval( 1.0, -1.0));\n"
1303 "       vec4 group3 = step(shadowmaptc.z, texval(-1.0,  1.0));\n"
1304 "       vec4 group4 = step(shadowmaptc.z, texval( 1.0,  1.0));\n"
1305 "       vec4 cols = vec4(group1.rg, group2.rg) + vec4(group3.ab, group4.ab) +\n"
1306 "                               mix(vec4(group1.ab, group2.ab), vec4(group3.rg, group4.rg), offset.y);\n"
1307 "       f = dot(mix(cols.xyz, cols.yzw, offset.x), vec3(1.0/9.0));\n"
1308 "#      endif\n"
1309 "#     else\n"
1310 "#      ifdef GL_EXT_gpu_shader4\n"
1311 "#        define texval(x, y) texture2DOffset(Texture_ShadowMap2D, center, ivec2(x, y)).r\n"
1312 "#      else\n"
1313 "#        define texval(x, y) texture2D(Texture_ShadowMap2D, center + vec2(x, y)*ShadowMap_TextureScale).r  \n"
1314 "#      endif\n"
1315 "#      if USESHADOWMAPPCF > 1\n"
1316 "       vec2 center = shadowmaptc.xy - 0.5, offset = fract(center);\n"
1317 "       center *= ShadowMap_TextureScale;\n"
1318 "       vec4 row1 = step(shadowmaptc.z, vec4(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0), texval( 2.0, -1.0)));\n"
1319 "       vec4 row2 = step(shadowmaptc.z, vec4(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0), texval( 2.0,  0.0)));\n"
1320 "       vec4 row3 = step(shadowmaptc.z, vec4(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0), texval( 2.0,  1.0)));\n"
1321 "       vec4 row4 = step(shadowmaptc.z, vec4(texval(-1.0,  2.0), texval( 0.0,  2.0), texval( 1.0,  2.0), texval( 2.0,  2.0)));\n"
1322 "       vec4 cols = row2 + row3 + mix(row1, row4, offset.y);\n"
1323 "       f = dot(mix(cols.xyz, cols.yzw, offset.x), vec3(1.0/9.0));\n"
1324 "#      else\n"
1325 "       vec2 center = shadowmaptc.xy*ShadowMap_TextureScale, offset = fract(shadowmaptc.xy);\n"
1326 "       vec3 row1 = step(shadowmaptc.z, vec3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n"
1327 "       vec3 row2 = step(shadowmaptc.z, vec3(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0)));\n"
1328 "       vec3 row3 = step(shadowmaptc.z, vec3(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0)));\n"
1329 "       vec3 cols = row2 + mix(row1, row3, offset.y);\n"
1330 "       f = dot(mix(cols.xy, cols.yz, offset.x), vec2(0.25));\n"
1331 "#      endif\n"
1332 "#     endif\n"
1333 "#    else\n"
1334 "       f = step(shadowmaptc.z, texture2D(Texture_ShadowMap2D, shadowmaptc.xy*ShadowMap_TextureScale).r);\n"
1335 "#    endif\n"
1336 "#  endif\n"
1337 "#  ifdef USESHADOWMAPORTHO\n"
1338 "       return mix(ShadowMap_Parameters.w, 1.0, f);\n"
1339 "#  else\n"
1340 "       return f;\n"
1341 "#  endif\n"
1342 "}\n"
1343 "# endif\n"
1344 "\n"
1345 "# ifdef USESHADOWMAPCUBE\n"
1346 "float ShadowMapCompare(vec3 dir)\n"
1347 "{\n"
1348 "       // apply depth texture cubemap as light filter\n"
1349 "       vec4 shadowmaptc = GetShadowMapTCCube(dir);\n"
1350 "       float f;\n"
1351 "#  ifdef USESHADOWSAMPLER\n"
1352 "       f = shadowCube(Texture_ShadowMapCube, shadowmaptc).r;\n"
1353 "#  else\n"
1354 "       f = step(shadowmaptc.w, textureCube(Texture_ShadowMapCube, shadowmaptc.xyz).r);\n"
1355 "#  endif\n"
1356 "       return f;\n"
1357 "}\n"
1358 "# endif\n"
1359 "#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE) && !defined(USESHADOWMAPORTHO)\n"
1360 "#endif // FRAGMENT_SHADER\n"
1361 "\n"
1362 "\n"
1363 "\n"
1364 "\n"
1365 "#ifdef MODE_DEFERREDGEOMETRY\n"
1366 "#ifdef VERTEX_SHADER\n"
1367 "uniform mat4 TexMatrix;\n"
1368 "#ifdef USEVERTEXTEXTUREBLEND\n"
1369 "uniform mat4 BackgroundTexMatrix;\n"
1370 "#endif\n"
1371 "uniform mat4 ModelViewMatrix;\n"
1372 "void main(void)\n"
1373 "{\n"
1374 "       TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
1375 "#ifdef USEVERTEXTEXTUREBLEND\n"
1376 "       gl_FrontColor = gl_Color;\n"
1377 "       TexCoord2 = vec2(BackgroundTexMatrix * gl_MultiTexCoord0);\n"
1378 "#endif\n"
1379 "\n"
1380 "       // transform unnormalized eye direction into tangent space\n"
1381 "#ifdef USEOFFSETMAPPING\n"
1382 "       vec3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
1383 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
1384 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
1385 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
1386 "#endif\n"
1387 "\n"
1388 "       VectorS = (ModelViewMatrix * vec4(gl_MultiTexCoord1.xyz, 0)).xyz;\n"
1389 "       VectorT = (ModelViewMatrix * vec4(gl_MultiTexCoord2.xyz, 0)).xyz;\n"
1390 "       VectorR = (ModelViewMatrix * vec4(gl_MultiTexCoord3.xyz, 0)).xyz;\n"
1391 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
1392 "}\n"
1393 "#endif // VERTEX_SHADER\n"
1394 "\n"
1395 "#ifdef FRAGMENT_SHADER\n"
1396 "void main(void)\n"
1397 "{\n"
1398 "#ifdef USEOFFSETMAPPING\n"
1399 "       // apply offsetmapping\n"
1400 "       vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
1401 "#define TexCoord TexCoordOffset\n"
1402 "#endif\n"
1403 "\n"
1404 "#ifdef USEALPHAKILL\n"
1405 "       if (texture2D(Texture_Color, TexCoord).a < 0.5)\n"
1406 "               discard;\n"
1407 "#endif\n"
1408 "\n"
1409 "#ifdef USEVERTEXTEXTUREBLEND\n"
1410 "       float alpha = texture2D(Texture_Color, TexCoord).a;\n"
1411 "       float terrainblend = clamp(float(gl_Color.a) * alpha * 2.0 - 0.5, float(0.0), float(1.0));\n"
1412 "       //float terrainblend = min(float(gl_Color.a) * alpha * 2.0, float(1.0));\n"
1413 "       //float terrainblend = float(gl_Color.a) * alpha > 0.5;\n"
1414 "#endif\n"
1415 "\n"
1416 "#ifdef USEVERTEXTEXTUREBLEND\n"
1417 "       vec3 surfacenormal = mix(vec3(texture2D(Texture_SecondaryNormal, TexCoord2)), vec3(texture2D(Texture_Normal, TexCoord)), terrainblend) - vec3(0.5, 0.5, 0.5);\n"
1418 "       float a = mix(texture2D(Texture_SecondaryGloss, TexCoord2).a, texture2D(Texture_Gloss, TexCoord).a, terrainblend);\n"
1419 "#else\n"
1420 "       vec3 surfacenormal = vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5, 0.5, 0.5);\n"
1421 "       float a = texture2D(Texture_Gloss, TexCoord).a;\n"
1422 "#endif\n"
1423 "\n"
1424 "       gl_FragColor = vec4(normalize(surfacenormal.x * VectorS + surfacenormal.y * VectorT + surfacenormal.z * VectorR) * 0.5 + vec3(0.5, 0.5, 0.5), a);\n"
1425 "}\n"
1426 "#endif // FRAGMENT_SHADER\n"
1427 "#else // !MODE_DEFERREDGEOMETRY\n"
1428 "\n"
1429 "\n"
1430 "\n"
1431 "\n"
1432 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
1433 "#ifdef VERTEX_SHADER\n"
1434 "uniform mat4 ModelViewMatrix;\n"
1435 "void main(void)\n"
1436 "{\n"
1437 "       ModelViewPosition = ModelViewMatrix * gl_Vertex;\n"
1438 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
1439 "}\n"
1440 "#endif // VERTEX_SHADER\n"
1441 "\n"
1442 "#ifdef FRAGMENT_SHADER\n"
1443 "uniform mat4 ViewToLight;\n"
1444 "// ScreenToDepth = vec2(Far / (Far - Near), Far * Near / (Near - Far));\n"
1445 "uniform vec2 ScreenToDepth;\n"
1446 "uniform myhalf3 DeferredColor_Ambient;\n"
1447 "uniform myhalf3 DeferredColor_Diffuse;\n"
1448 "#ifdef USESPECULAR\n"
1449 "uniform myhalf3 DeferredColor_Specular;\n"
1450 "uniform myhalf SpecularPower;\n"
1451 "#endif\n"
1452 "uniform myhalf2 PixelToScreenTexCoord;\n"
1453 "void main(void)\n"
1454 "{\n"
1455 "       // calculate viewspace pixel position\n"
1456 "       vec2 ScreenTexCoord = gl_FragCoord.xy * PixelToScreenTexCoord;\n"
1457 "       vec3 position;\n"
1458 "       position.z = ScreenToDepth.y / (texture2D(Texture_ScreenDepth, ScreenTexCoord).r + ScreenToDepth.x);\n"
1459 "       position.xy = ModelViewPosition.xy * (position.z / ModelViewPosition.z);\n"
1460 "       // decode viewspace pixel normal\n"
1461 "       myhalf4 normalmap = texture2D(Texture_ScreenNormalMap, ScreenTexCoord);\n"
1462 "       myhalf3 surfacenormal = normalize(normalmap.rgb - myhalf3(0.5,0.5,0.5));\n"
1463 "       // surfacenormal = pixel normal in viewspace\n"
1464 "       // LightVector = pixel to light in viewspace\n"
1465 "       // CubeVector = position in lightspace\n"
1466 "       // eyevector = pixel to view in viewspace\n"
1467 "       vec3 CubeVector = vec3(ViewToLight * vec4(position,1));\n"
1468 "       myhalf fade = myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n"
1469 "#ifdef USEDIFFUSE\n"
1470 "       // calculate diffuse shading\n"
1471 "       myhalf3 lightnormal = myhalf3(normalize(LightPosition - position));\n"
1472 "       myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
1473 "#endif\n"
1474 "#ifdef USESPECULAR\n"
1475 "       // calculate directional shading\n"
1476 "       vec3 eyevector = position * -1.0;\n"
1477 "#  ifdef USEEXACTSPECULARMATH\n"
1478 "       myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(eyevector)))*-1.0, 0.0)), SpecularPower * normalmap.a);\n"
1479 "#  else\n"
1480 "       myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(eyevector)));\n"
1481 "       myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * normalmap.a);\n"
1482 "#  endif\n"
1483 "#endif\n"
1484 "\n"
1485 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAPCUBE) || defined(USESHADOWMAP2D)\n"
1486 "       fade *= ShadowMapCompare(CubeVector);\n"
1487 "#endif\n"
1488 "\n"
1489 "#ifdef USEDIFFUSE\n"
1490 "       gl_FragData[0] = vec4((DeferredColor_Ambient + DeferredColor_Diffuse * diffuse) * fade, 1.0);\n"
1491 "#else\n"
1492 "       gl_FragData[0] = vec4(DeferredColor_Ambient * fade, 1.0);\n"
1493 "#endif\n"
1494 "#ifdef USESPECULAR\n"
1495 "       gl_FragData[1] = vec4(DeferredColor_Specular * (specular * fade), 1.0);\n"
1496 "#else\n"
1497 "       gl_FragData[1] = vec4(0.0, 0.0, 0.0, 1.0);\n"
1498 "#endif\n"
1499 "\n"
1500 "# ifdef USECUBEFILTER\n"
1501 "       vec3 cubecolor = textureCube(Texture_Cube, CubeVector).rgb;\n"
1502 "       gl_FragData[0].rgb *= cubecolor;\n"
1503 "       gl_FragData[1].rgb *= cubecolor;\n"
1504 "# endif\n"
1505 "}\n"
1506 "#endif // FRAGMENT_SHADER\n"
1507 "#else // !MODE_DEFERREDLIGHTSOURCE\n"
1508 "\n"
1509 "\n"
1510 "\n"
1511 "\n"
1512 "#ifdef VERTEX_SHADER\n"
1513 "uniform mat4 TexMatrix;\n"
1514 "#ifdef USEVERTEXTEXTUREBLEND\n"
1515 "uniform mat4 BackgroundTexMatrix;\n"
1516 "#endif\n"
1517 "#ifdef MODE_LIGHTSOURCE\n"
1518 "uniform mat4 ModelToLight;\n"
1519 "#endif\n"
1520 "#ifdef USESHADOWMAPORTHO\n"
1521 "uniform mat4 ShadowMapMatrix;\n"
1522 "#endif\n"
1523 "void main(void)\n"
1524 "{\n"
1525 "#if defined(MODE_VERTEXCOLOR) || defined(USEVERTEXTEXTUREBLEND)\n"
1526 "       gl_FrontColor = gl_Color;\n"
1527 "#endif\n"
1528 "       // copy the surface texcoord\n"
1529 "       TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
1530 "#ifdef USEVERTEXTEXTUREBLEND\n"
1531 "       TexCoord2 = vec2(BackgroundTexMatrix * gl_MultiTexCoord0);\n"
1532 "#endif\n"
1533 "#ifdef USELIGHTMAP\n"
1534 "       TexCoordLightmap = vec2(gl_MultiTexCoord4);\n"
1535 "#endif\n"
1536 "\n"
1537 "#ifdef MODE_LIGHTSOURCE\n"
1538 "       // transform vertex position into light attenuation/cubemap space\n"
1539 "       // (-1 to +1 across the light box)\n"
1540 "       CubeVector = vec3(ModelToLight * gl_Vertex);\n"
1541 "\n"
1542 "# ifdef USEDIFFUSE\n"
1543 "       // transform unnormalized light direction into tangent space\n"
1544 "       // (we use unnormalized to ensure that it interpolates correctly and then\n"
1545 "       //  normalize it per pixel)\n"
1546 "       vec3 lightminusvertex = LightPosition - gl_Vertex.xyz;\n"
1547 "       LightVector.x = dot(lightminusvertex, gl_MultiTexCoord1.xyz);\n"
1548 "       LightVector.y = dot(lightminusvertex, gl_MultiTexCoord2.xyz);\n"
1549 "       LightVector.z = dot(lightminusvertex, gl_MultiTexCoord3.xyz);\n"
1550 "# endif\n"
1551 "#endif\n"
1552 "\n"
1553 "#if defined(MODE_LIGHTDIRECTION) && defined(USEDIFFUSE)\n"
1554 "       LightVector.x = dot(LightDir, gl_MultiTexCoord1.xyz);\n"
1555 "       LightVector.y = dot(LightDir, gl_MultiTexCoord2.xyz);\n"
1556 "       LightVector.z = dot(LightDir, gl_MultiTexCoord3.xyz);\n"
1557 "#endif\n"
1558 "\n"
1559 "       // transform unnormalized eye direction into tangent space\n"
1560 "#ifdef USEEYEVECTOR\n"
1561 "       vec3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
1562 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
1563 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
1564 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
1565 "#endif\n"
1566 "\n"
1567 "#ifdef USEFOG\n"
1568 "       EyeVectorModelSpaceFogPlaneVertexDist.xyz = EyePosition - gl_Vertex.xyz;\n"
1569 "       EyeVectorModelSpaceFogPlaneVertexDist.w = dot(FogPlane, gl_Vertex);\n"
1570 "#endif\n"
1571 "\n"
1572 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(USEREFLECTCUBE)\n"
1573 "       VectorS = gl_MultiTexCoord1.xyz;\n"
1574 "       VectorT = gl_MultiTexCoord2.xyz;\n"
1575 "       VectorR = gl_MultiTexCoord3.xyz;\n"
1576 "#endif\n"
1577 "\n"
1578 "       // transform vertex to camera space, using ftransform to match non-VS rendering\n"
1579 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
1580 "\n"
1581 "#ifdef USESHADOWMAPORTHO\n"
1582 "       ShadowMapTC = vec3(ShadowMapMatrix * gl_Position);\n"
1583 "#endif\n"
1584 "\n"
1585 "#ifdef USEREFLECTION\n"
1586 "       ModelViewProjectionPosition = gl_Position;\n"
1587 "#endif\n"
1588 "}\n"
1589 "#endif // VERTEX_SHADER\n"
1590 "\n"
1591 "\n"
1592 "\n"
1593 "\n"
1594 "#ifdef FRAGMENT_SHADER\n"
1595 "#ifdef USEDEFERREDLIGHTMAP\n"
1596 "uniform myhalf2 PixelToScreenTexCoord;\n"
1597 "uniform myhalf3 DeferredMod_Diffuse;\n"
1598 "uniform myhalf3 DeferredMod_Specular;\n"
1599 "#endif\n"
1600 "uniform myhalf3 Color_Ambient;\n"
1601 "uniform myhalf3 Color_Diffuse;\n"
1602 "uniform myhalf3 Color_Specular;\n"
1603 "uniform myhalf SpecularPower;\n"
1604 "#ifdef USEGLOW\n"
1605 "uniform myhalf3 Color_Glow;\n"
1606 "#endif\n"
1607 "uniform myhalf Alpha;\n"
1608 "#ifdef USEREFLECTION\n"
1609 "uniform vec4 DistortScaleRefractReflect;\n"
1610 "uniform vec4 ScreenScaleRefractReflect;\n"
1611 "uniform vec4 ScreenCenterRefractReflect;\n"
1612 "uniform myhalf4 ReflectColor;\n"
1613 "#endif\n"
1614 "#ifdef USEREFLECTCUBE\n"
1615 "uniform mat4 ModelToReflectCube;\n"
1616 "uniform sampler2D Texture_ReflectMask;\n"
1617 "uniform samplerCube Texture_ReflectCube;\n"
1618 "#endif\n"
1619 "#ifdef MODE_LIGHTDIRECTION\n"
1620 "uniform myhalf3 LightColor;\n"
1621 "#endif\n"
1622 "#ifdef MODE_LIGHTSOURCE\n"
1623 "uniform myhalf3 LightColor;\n"
1624 "#endif\n"
1625 "void main(void)\n"
1626 "{\n"
1627 "#ifdef USEOFFSETMAPPING\n"
1628 "       // apply offsetmapping\n"
1629 "       vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
1630 "#define TexCoord TexCoordOffset\n"
1631 "#endif\n"
1632 "\n"
1633 "       // combine the diffuse textures (base, pants, shirt)\n"
1634 "       myhalf4 color = myhalf4(texture2D(Texture_Color, TexCoord));\n"
1635 "#ifdef USEALPHAKILL\n"
1636 "       if (color.a < 0.5)\n"
1637 "               discard;\n"
1638 "#endif\n"
1639 "       color.a *= Alpha;\n"
1640 "#ifdef USECOLORMAPPING\n"
1641 "       color.rgb += myhalf3(texture2D(Texture_Pants, TexCoord)) * Color_Pants + myhalf3(texture2D(Texture_Shirt, TexCoord)) * Color_Shirt;\n"
1642 "#endif\n"
1643 "#ifdef USEVERTEXTEXTUREBLEND\n"
1644 "       myhalf terrainblend = clamp(myhalf(gl_Color.a) * color.a * 2.0 - 0.5, myhalf(0.0), myhalf(1.0));\n"
1645 "       //myhalf terrainblend = min(myhalf(gl_Color.a) * color.a * 2.0, myhalf(1.0));\n"
1646 "       //myhalf terrainblend = myhalf(gl_Color.a) * color.a > 0.5;\n"
1647 "       color.rgb = mix(myhalf3(texture2D(Texture_SecondaryColor, TexCoord2)), color.rgb, terrainblend);\n"
1648 "       color.a = 1.0;\n"
1649 "       //color = mix(myhalf4(1, 0, 0, 1), color, terrainblend);\n"
1650 "#endif\n"
1651 "\n"
1652 "       // get the surface normal\n"
1653 "#ifdef USEVERTEXTEXTUREBLEND\n"
1654 "       myhalf3 surfacenormal = normalize(mix(myhalf3(texture2D(Texture_SecondaryNormal, TexCoord2)), myhalf3(texture2D(Texture_Normal, TexCoord)), terrainblend) - myhalf3(0.5, 0.5, 0.5));\n"
1655 "#else\n"
1656 "       myhalf3 surfacenormal = normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5, 0.5, 0.5));\n"
1657 "#endif\n"
1658 "\n"
1659 "       // get the material colors\n"
1660 "       myhalf3 diffusetex = color.rgb;\n"
1661 "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
1662 "# ifdef USEVERTEXTEXTUREBLEND\n"
1663 "       myhalf4 glosstex = mix(myhalf4(texture2D(Texture_SecondaryGloss, TexCoord2)), myhalf4(texture2D(Texture_Gloss, TexCoord)), terrainblend);\n"
1664 "# else\n"
1665 "       myhalf4 glosstex = myhalf4(texture2D(Texture_Gloss, TexCoord));\n"
1666 "# endif\n"
1667 "#endif\n"
1668 "\n"
1669 "#ifdef USEREFLECTCUBE\n"
1670 "       vec3 TangentReflectVector = reflect(-EyeVector, surfacenormal);\n"
1671 "       vec3 ModelReflectVector = TangentReflectVector.x * VectorS + TangentReflectVector.y * VectorT + TangentReflectVector.z * VectorR;\n"
1672 "       vec3 ReflectCubeTexCoord = vec3(ModelToReflectCube * vec4(ModelReflectVector, 0));\n"
1673 "       diffusetex += myhalf3(texture2D(Texture_ReflectMask, TexCoord)) * myhalf3(textureCube(Texture_ReflectCube, ReflectCubeTexCoord));\n"
1674 "#endif\n"
1675 "\n"
1676 "\n"
1677 "\n"
1678 "\n"
1679 "#ifdef MODE_LIGHTSOURCE\n"
1680 "       // light source\n"
1681 "#ifdef USEDIFFUSE\n"
1682 "       myhalf3 lightnormal = myhalf3(normalize(LightVector));\n"
1683 "       myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
1684 "       color.rgb = diffusetex * (Color_Ambient + diffuse * Color_Diffuse);\n"
1685 "#ifdef USESPECULAR\n"
1686 "#ifdef USEEXACTSPECULARMATH\n"
1687 "       myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a);\n"
1688 "#else\n"
1689 "       myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(EyeVector)));\n"
1690 "       myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a);\n"
1691 "#endif\n"
1692 "       color.rgb += glosstex.rgb * (specular * Color_Specular);\n"
1693 "#endif\n"
1694 "#else\n"
1695 "       color.rgb = diffusetex * Color_Ambient;\n"
1696 "#endif\n"
1697 "       color.rgb *= LightColor;\n"
1698 "       color.rgb *= myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n"
1699 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAPCUBE) || defined(USESHADOWMAP2D)\n"
1700 "       color.rgb *= ShadowMapCompare(CubeVector);\n"
1701 "#endif\n"
1702 "# ifdef USECUBEFILTER\n"
1703 "       color.rgb *= myhalf3(textureCube(Texture_Cube, CubeVector));\n"
1704 "# endif\n"
1705 "#endif // MODE_LIGHTSOURCE\n"
1706 "\n"
1707 "\n"
1708 "\n"
1709 "\n"
1710 "#ifdef MODE_LIGHTDIRECTION\n"
1711 "#define SHADING\n"
1712 "#ifdef USEDIFFUSE\n"
1713 "       myhalf3 lightnormal = myhalf3(normalize(LightVector));\n"
1714 "#endif\n"
1715 "#define lightcolor LightColor\n"
1716 "#endif // MODE_LIGHTDIRECTION\n"
1717 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
1718 "#define SHADING\n"
1719 "       // deluxemap lightmapping using light vectors in modelspace (q3map2 -light -deluxe)\n"
1720 "       myhalf3 lightnormal_modelspace = myhalf3(texture2D(Texture_Deluxemap, TexCoordLightmap)) * 2.0 + myhalf3(-1.0, -1.0, -1.0);\n"
1721 "       myhalf3 lightcolor = myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap));\n"
1722 "       // convert modelspace light vector to tangentspace\n"
1723 "       myhalf3 lightnormal;\n"
1724 "       lightnormal.x = dot(lightnormal_modelspace, myhalf3(VectorS));\n"
1725 "       lightnormal.y = dot(lightnormal_modelspace, myhalf3(VectorT));\n"
1726 "       lightnormal.z = dot(lightnormal_modelspace, myhalf3(VectorR));\n"
1727 "       // calculate directional shading (and undoing the existing angle attenuation on the lightmap by the division)\n"
1728 "       // note that q3map2 is too stupid to calculate proper surface normals when q3map_nonplanar\n"
1729 "       // is used (the lightmap and deluxemap coords correspond to virtually random coordinates\n"
1730 "       // on that luxel, and NOT to its center, because recursive triangle subdivision is used\n"
1731 "       // to map the luxels to coordinates on the draw surfaces), which also causes\n"
1732 "       // deluxemaps to be wrong because light contributions from the wrong side of the surface\n"
1733 "       // are added up. To prevent divisions by zero or strong exaggerations, a max()\n"
1734 "       // nudge is done here at expense of some additional fps. This is ONLY needed for\n"
1735 "       // deluxemaps, tangentspace deluxemap avoid this problem by design.\n"
1736 "       lightcolor *= 1.0 / max(0.25, lightnormal.z);\n"
1737 "#endif // MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
1738 "#ifdef MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
1739 "#define SHADING\n"
1740 "       // deluxemap lightmapping using light vectors in tangentspace (hmap2 -light)\n"
1741 "       myhalf3 lightnormal = myhalf3(texture2D(Texture_Deluxemap, TexCoordLightmap)) * 2.0 + myhalf3(-1.0, -1.0, -1.0);\n"
1742 "       myhalf3 lightcolor = myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap));\n"
1743 "#endif\n"
1744 "\n"
1745 "\n"
1746 "\n"
1747 "\n"
1748 "#ifdef MODE_LIGHTMAP\n"
1749 "       color.rgb = diffusetex * (Color_Ambient + myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap)) * Color_Diffuse);\n"
1750 "#endif // MODE_LIGHTMAP\n"
1751 "#ifdef MODE_VERTEXCOLOR\n"
1752 "       color.rgb = diffusetex * (Color_Ambient + myhalf3(gl_Color.rgb) * Color_Diffuse);\n"
1753 "#endif // MODE_VERTEXCOLOR\n"
1754 "#ifdef MODE_FLATCOLOR\n"
1755 "       color.rgb = diffusetex * Color_Ambient;\n"
1756 "#endif // MODE_FLATCOLOR\n"
1757 "\n"
1758 "\n"
1759 "\n"
1760 "\n"
1761 "#ifdef SHADING\n"
1762 "# ifdef USEDIFFUSE\n"
1763 "       myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
1764 "#  ifdef USESPECULAR\n"
1765 "#   ifdef USEEXACTSPECULARMATH\n"
1766 "       myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a);\n"
1767 "#   else\n"
1768 "       myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(EyeVector)));\n"
1769 "       myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a);\n"
1770 "#   endif\n"
1771 "       color.rgb = diffusetex * Color_Ambient + (diffusetex * Color_Diffuse * diffuse + glosstex.rgb * Color_Specular * specular) * lightcolor;\n"
1772 "#  else\n"
1773 "       color.rgb = diffusetex * (Color_Ambient + Color_Diffuse * diffuse * lightcolor);\n"
1774 "#  endif\n"
1775 "# else\n"
1776 "       color.rgb = diffusetex * Color_Ambient;\n"
1777 "# endif\n"
1778 "#endif\n"
1779 "\n"
1780 "#ifdef USESHADOWMAPORTHO\n"
1781 "       color.rgb *= ShadowMapCompare(ShadowMapTC);\n"
1782 "#endif\n"
1783 "\n"
1784 "#ifdef USEDEFERREDLIGHTMAP\n"
1785 "       vec2 ScreenTexCoord = gl_FragCoord.xy * PixelToScreenTexCoord;\n"
1786 "       color.rgb += diffusetex * myhalf3(texture2D(Texture_ScreenDiffuse, ScreenTexCoord)) * DeferredMod_Diffuse;\n"
1787 "       color.rgb += glosstex.rgb * myhalf3(texture2D(Texture_ScreenSpecular, ScreenTexCoord)) * DeferredMod_Specular;\n"
1788 "#endif\n"
1789 "\n"
1790 "#ifdef USEGLOW\n"
1791 "#ifdef USEVERTEXTEXTUREBLEND\n"
1792 "       color.rgb += mix(myhalf3(texture2D(Texture_SecondaryGlow, TexCoord2)), myhalf3(texture2D(Texture_Glow, TexCoord)), terrainblend) * Color_Glow;\n"
1793 "#else\n"
1794 "       color.rgb += myhalf3(texture2D(Texture_Glow, TexCoord)) * Color_Glow;\n"
1795 "#endif\n"
1796 "#endif\n"
1797 "\n"
1798 "#ifdef USEFOG\n"
1799 "       color.rgb = FogVertex(color.rgb);\n"
1800 "#endif\n"
1801 "\n"
1802 "       // reflection must come last because it already contains exactly the correct fog (the reflection render preserves camera distance from the plane, it only flips the side) and ContrastBoost/SceneBrightness\n"
1803 "#ifdef USEREFLECTION\n"
1804 "       vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
1805 "       //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
1806 "       vec2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW.zw + ScreenCenterRefractReflect.zw;\n"
1807 "       vec2 ScreenTexCoord = SafeScreenTexCoord + vec3(normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5))).xy * DistortScaleRefractReflect.zw;\n"
1808 "       // FIXME temporary hack to detect the case that the reflection\n"
1809 "       // gets blackened at edges due to leaving the area that contains actual\n"
1810 "       // content.\n"
1811 "       // Remove this 'ack once we have a better way to stop this thing from\n"
1812 "       // 'appening.\n"
1813 "       float f = min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(0.01, 0.01)).rgb) / 0.05);\n"
1814 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(0.01, -0.01)).rgb) / 0.05);\n"
1815 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
1816 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
1817 "       ScreenTexCoord = mix(SafeScreenTexCoord, ScreenTexCoord, f);\n"
1818 "       color.rgb = mix(color.rgb, myhalf3(texture2D(Texture_Reflection, ScreenTexCoord)) * ReflectColor.rgb, ReflectColor.a);\n"
1819 "#endif\n"
1820 "\n"
1821 "       gl_FragColor = vec4(color);\n"
1822 "}\n"
1823 "#endif // FRAGMENT_SHADER\n"
1824 "\n"
1825 "#endif // !MODE_DEFERREDLIGHTSOURCE\n"
1826 "#endif // !MODE_DEFERREDGEOMETRY\n"
1827 "#endif // !MODE_WATER\n"
1828 "#endif // !MODE_REFRACTION\n"
1829 "#endif // !MODE_BLOOMBLUR\n"
1830 "#endif // !MODE_GENERIC\n"
1831 "#endif // !MODE_POSTPROCESS\n"
1832 "#endif // !MODE_SHOWDEPTH\n"
1833 "#endif // !MODE_DEPTH_OR_SHADOW\n"
1834 ;
1835
1836 /*
1837 =========================================================================================================================================================
1838
1839
1840
1841 =========================================================================================================================================================
1842
1843
1844
1845 =========================================================================================================================================================
1846
1847
1848
1849 =========================================================================================================================================================
1850
1851
1852
1853 =========================================================================================================================================================
1854
1855
1856
1857 =========================================================================================================================================================
1858
1859
1860
1861 =========================================================================================================================================================
1862 */
1863
1864 const char *builtincgshaderstring =
1865 "// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
1866 "// written by Forest 'LordHavoc' Hale\n"
1867 "// shadowmapping enhancements by Lee 'eihrul' Salzman\n"
1868 "\n"
1869 "// FIXME: we need to get rid of ModelViewProjectionPosition to make room for the texcoord for this\n"
1870 "#if defined(USEREFLECTION)\n"
1871 "#undef USESHADOWMAPORTHO\n"
1872 "#endif\n"
1873 "\n"
1874 "#if defined(USEFOGINSIDE) || defined(USEFOGOUTSIDE) || defined(USEFOGHEIGHTTEXTURE)\n"
1875 "# define USEFOG\n"
1876 "#endif\n"
1877 "#if defined(MODE_LIGHTMAP) || defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
1878 "#define USELIGHTMAP\n"
1879 "#endif\n"
1880 "#if defined(USESPECULAR) || defined(USEOFFSETMAPPING) || defined(USEREFLECTCUBE)\n"
1881 "#define USEEYEVECTOR\n"
1882 "#endif\n"
1883 "\n"
1884 "#ifdef FRAGMENT_SHADER\n"
1885 "#define texDepth2D(tex,texcoord) tex2D(tex,texcoord).r\n"
1886 "#endif\n"
1887 "\n"
1888 "#ifdef MODE_DEPTH_OR_SHADOW\n"
1889 "#ifdef VERTEX_SHADER\n"
1890 "void main\n"
1891 "(\n"
1892 "float4 gl_Vertex : POSITION,\n"
1893 "uniform float4x4 ModelViewProjectionMatrix,\n"
1894 "out float4 gl_Position : POSITION\n"
1895 ")\n"
1896 "{\n"
1897 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
1898 "}\n"
1899 "#endif\n"
1900 "#else // !MODE_DEPTH_ORSHADOW\n"
1901 "\n"
1902 "\n"
1903 "\n"
1904 "\n"
1905 "#ifdef MODE_SHOWDEPTH\n"
1906 "#ifdef VERTEX_SHADER\n"
1907 "void main\n"
1908 "(\n"
1909 "float4 gl_Vertex : POSITION,\n"
1910 "uniform float4x4 ModelViewProjectionMatrix,\n"
1911 "out float4 gl_Position : POSITION,\n"
1912 "out float4 gl_FrontColor : COLOR0\n"
1913 ")\n"
1914 "{\n"
1915 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
1916 "       gl_FrontColor = float4(gl_Position.z, gl_Position.z, gl_Position.z, 1.0);\n"
1917 "}\n"
1918 "#endif\n"
1919 "\n"
1920 "#ifdef FRAGMENT_SHADER\n"
1921 "void main\n"
1922 "(\n"
1923 "float4 gl_FrontColor : COLOR0,\n"
1924 "out float4 gl_FragColor : COLOR\n"
1925 ")\n"
1926 "{\n"
1927 "       gl_FragColor = gl_FrontColor;\n"
1928 "}\n"
1929 "#endif\n"
1930 "#else // !MODE_SHOWDEPTH\n"
1931 "\n"
1932 "\n"
1933 "\n"
1934 "\n"
1935 "#ifdef MODE_POSTPROCESS\n"
1936 "\n"
1937 "#ifdef VERTEX_SHADER\n"
1938 "void main\n"
1939 "(\n"
1940 "float4 gl_Vertex : POSITION,\n"
1941 "uniform float4x4 ModelViewProjectionMatrix,\n"
1942 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
1943 "float4 gl_MultiTexCoord1 : TEXCOORD1,\n"
1944 "out float4 gl_Position : POSITION,\n"
1945 "out float2 TexCoord1 : TEXCOORD0,\n"
1946 "out float2 TexCoord2 : TEXCOORD1\n"
1947 ")\n"
1948 "{\n"
1949 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
1950 "       TexCoord1 = gl_MultiTexCoord0.xy;\n"
1951 "#ifdef USEBLOOM\n"
1952 "       TexCoord2 = gl_MultiTexCoord1.xy;\n"
1953 "#endif\n"
1954 "}\n"
1955 "#endif\n"
1956 "\n"
1957 "#ifdef FRAGMENT_SHADER\n"
1958 "void main\n"
1959 "(\n"
1960 "float2 TexCoord1 : TEXCOORD0,\n"
1961 "float2 TexCoord2 : TEXCOORD1,\n"
1962 "uniform sampler2D Texture_First,\n"
1963 "#ifdef USEBLOOM\n"
1964 "uniform sampler2D Texture_Second,\n"
1965 "#endif\n"
1966 "#ifdef USEGAMMARAMPS\n"
1967 "uniform sampler2D Texture_GammaRamps,\n"
1968 "#endif\n"
1969 "#ifdef USESATURATION\n"
1970 "uniform float Saturation,\n"
1971 "#endif\n"
1972 "#ifdef USEVIEWTINT\n"
1973 "uniform float4 ViewTintColor,\n"
1974 "#endif\n"
1975 "uniform float4 UserVec1,\n"
1976 "uniform float4 UserVec2,\n"
1977 "uniform float4 UserVec3,\n"
1978 "uniform float4 UserVec4,\n"
1979 "uniform float ClientTime,\n"
1980 "uniform float2 PixelSize,\n"
1981 "out float4 gl_FragColor : COLOR\n"
1982 ")\n"
1983 "{\n"
1984 "       gl_FragColor = tex2D(Texture_First, TexCoord1);\n"
1985 "#ifdef USEBLOOM\n"
1986 "       gl_FragColor += tex2D(Texture_Second, TexCoord2);\n"
1987 "#endif\n"
1988 "#ifdef USEVIEWTINT\n"
1989 "       gl_FragColor = lerp(gl_FragColor, ViewTintColor, ViewTintColor.a);\n"
1990 "#endif\n"
1991 "\n"
1992 "#ifdef USEPOSTPROCESSING\n"
1993 "// do r_glsl_dumpshader, edit glsl/default.glsl, and replace this by your own postprocessing if you want\n"
1994 "// this code does a blur with the radius specified in the first component of r_glsl_postprocess_uservec1 and blends it using the second component\n"
1995 "       gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2(-0.987688, -0.156434)) * UserVec1.y;\n"
1996 "       gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2(-0.156434, -0.891007)) * UserVec1.y;\n"
1997 "       gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2( 0.891007, -0.453990)) * UserVec1.y;\n"
1998 "       gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2( 0.707107,  0.707107)) * UserVec1.y;\n"
1999 "       gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2(-0.453990,  0.891007)) * UserVec1.y;\n"
2000 "       gl_FragColor /= (1 + 5 * UserVec1.y);\n"
2001 "#endif\n"
2002 "\n"
2003 "#ifdef USESATURATION\n"
2004 "       //apply saturation BEFORE gamma ramps, so v_glslgamma value does not matter\n"
2005 "       float y = dot(gl_FragColor.rgb, float3(0.299, 0.587, 0.114));\n"
2006 "       //gl_FragColor = float3(y) + (gl_FragColor.rgb - float3(y)) * Saturation;\n"
2007 "       gl_FragColor.rgb = lerp(float3(y), gl_FragColor.rgb, Saturation);\n"
2008 "#endif\n"
2009 "\n"
2010 "#ifdef USEGAMMARAMPS\n"
2011 "       gl_FragColor.r = tex2D(Texture_GammaRamps, float2(gl_FragColor.r, 0)).r;\n"
2012 "       gl_FragColor.g = tex2D(Texture_GammaRamps, float2(gl_FragColor.g, 0)).g;\n"
2013 "       gl_FragColor.b = tex2D(Texture_GammaRamps, float2(gl_FragColor.b, 0)).b;\n"
2014 "#endif\n"
2015 "}\n"
2016 "#endif\n"
2017 "#else // !MODE_POSTPROCESS\n"
2018 "\n"
2019 "\n"
2020 "\n"
2021 "\n"
2022 "#ifdef MODE_GENERIC\n"
2023 "#ifdef VERTEX_SHADER\n"
2024 "void main\n"
2025 "(\n"
2026 "float4 gl_Vertex : POSITION,\n"
2027 "uniform float4x4 ModelViewProjectionMatrix,\n"
2028 "float4 gl_Color : COLOR0,\n"
2029 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2030 "float4 gl_MultiTexCoord1 : TEXCOORD1,\n"
2031 "out float4 gl_Position : POSITION,\n"
2032 "out float4 gl_FrontColor : COLOR,\n"
2033 "out float2 TexCoord1 : TEXCOORD0,\n"
2034 "out float2 TexCoord2 : TEXCOORD1\n"
2035 ")\n"
2036 "{\n"
2037 "       gl_FrontColor = gl_Color;\n"
2038 "#ifdef USEDIFFUSE\n"
2039 "       TexCoord1 = gl_MultiTexCoord0.xy;\n"
2040 "#endif\n"
2041 "#ifdef USESPECULAR\n"
2042 "       TexCoord2 = gl_MultiTexCoord1.xy;\n"
2043 "#endif\n"
2044 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2045 "}\n"
2046 "#endif\n"
2047 "\n"
2048 "#ifdef FRAGMENT_SHADER\n"
2049 "\n"
2050 "void main\n"
2051 "(\n"
2052 "float4 gl_FrontColor : COLOR,\n"
2053 "float2 TexCoord1 : TEXCOORD0,\n"
2054 "float2 TexCoord2 : TEXCOORD1,\n"
2055 "#ifdef USEDIFFUSE\n"
2056 "uniform sampler2D Texture_First,\n"
2057 "#endif\n"
2058 "#ifdef USESPECULAR\n"
2059 "uniform sampler2D Texture_Second,\n"
2060 "#endif\n"
2061 "out float4 gl_FragColor : COLOR\n"
2062 ")\n"
2063 "{\n"
2064 "       gl_FragColor = gl_FrontColor;\n"
2065 "#ifdef USEDIFFUSE\n"
2066 "       gl_FragColor *= tex2D(Texture_First, TexCoord1);\n"
2067 "#endif\n"
2068 "\n"
2069 "#ifdef USESPECULAR\n"
2070 "       float4 tex2 = tex2D(Texture_Second, TexCoord2);\n"
2071 "# ifdef USECOLORMAPPING\n"
2072 "       gl_FragColor *= tex2;\n"
2073 "# endif\n"
2074 "# ifdef USEGLOW\n"
2075 "       gl_FragColor += tex2;\n"
2076 "# endif\n"
2077 "# ifdef USEVERTEXTEXTUREBLEND\n"
2078 "       gl_FragColor = lerp(gl_FragColor, tex2, tex2.a);\n"
2079 "# endif\n"
2080 "#endif\n"
2081 "}\n"
2082 "#endif\n"
2083 "#else // !MODE_GENERIC\n"
2084 "\n"
2085 "\n"
2086 "\n"
2087 "\n"
2088 "#ifdef MODE_BLOOMBLUR\n"
2089 "#ifdef VERTEX_SHADER\n"
2090 "void main\n"
2091 "(\n"
2092 "float4 gl_Vertex : POSITION,\n"
2093 "uniform float4x4 ModelViewProjectionMatrix,\n"
2094 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2095 "out float4 gl_Position : POSITION,\n"
2096 "out float2 TexCoord : TEXCOORD0\n"
2097 ")\n"
2098 "{\n"
2099 "       TexCoord = gl_MultiTexCoord0.xy;\n"
2100 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2101 "}\n"
2102 "#endif\n"
2103 "\n"
2104 "#ifdef FRAGMENT_SHADER\n"
2105 "\n"
2106 "void main\n"
2107 "(\n"
2108 "float2 TexCoord : TEXCOORD0,\n"
2109 "uniform sampler2D Texture_First,\n"
2110 "uniform float4 BloomBlur_Parameters,\n"
2111 "out float4 gl_FragColor : COLOR\n"
2112 ")\n"
2113 "{\n"
2114 "       int i;\n"
2115 "       float2 tc = TexCoord;\n"
2116 "       float3 color = tex2D(Texture_First, tc).rgb;\n"
2117 "       tc += BloomBlur_Parameters.xy;\n"
2118 "       for (i = 1;i < SAMPLES;i++)\n"
2119 "       {\n"
2120 "               color += tex2D(Texture_First, tc).rgb;\n"
2121 "               tc += BloomBlur_Parameters.xy;\n"
2122 "       }\n"
2123 "       gl_FragColor = float4(color * BloomBlur_Parameters.z + float3(BloomBlur_Parameters.w), 1);\n"
2124 "}\n"
2125 "#endif\n"
2126 "#else // !MODE_BLOOMBLUR\n"
2127 "#ifdef MODE_REFRACTION\n"
2128 "#ifdef VERTEX_SHADER\n"
2129 "void main\n"
2130 "(\n"
2131 "float4 gl_Vertex : POSITION,\n"
2132 "uniform float4x4 ModelViewProjectionMatrix,\n"
2133 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2134 "uniform float4x4 TexMatrix,\n"
2135 "uniform float3 EyePosition,\n"
2136 "out float4 gl_Position : POSITION,\n"
2137 "out float2 TexCoord : TEXCOORD0,\n"
2138 "out float3 EyeVector : TEXCOORD1,\n"
2139 "out float4 ModelViewProjectionPosition : TEXCOORD2\n"
2140 ")\n"
2141 "{\n"
2142 "       TexCoord = float2(mul(TexMatrix, gl_MultiTexCoord0));\n"
2143 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2144 "       ModelViewProjectionPosition = gl_Position;\n"
2145 "}\n"
2146 "#endif\n"
2147 "\n"
2148 "#ifdef FRAGMENT_SHADER\n"
2149 "void main\n"
2150 "(\n"
2151 "float2 TexCoord : TEXCOORD0,\n"
2152 "float3 EyeVector : TEXCOORD1,\n"
2153 "float4 ModelViewProjectionPosition : TEXCOORD2,\n"
2154 "uniform sampler2D Texture_Normal,\n"
2155 "uniform sampler2D Texture_Refraction,\n"
2156 "uniform sampler2D Texture_Reflection,\n"
2157 "uniform float4 DistortScaleRefractReflect,\n"
2158 "uniform float4 ScreenScaleRefractReflect,\n"
2159 "uniform float4 ScreenCenterRefractReflect,\n"
2160 "uniform float4 RefractColor,\n"
2161 "out float4 gl_FragColor : COLOR\n"
2162 ")\n"
2163 "{\n"
2164 "       float2 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect.xy * (1.0 / ModelViewProjectionPosition.w);\n"
2165 "       //float2 ScreenTexCoord = (ModelViewProjectionPosition.xy + normalize(float3(tex2D(Texture_Normal, TexCoord)) - float3(0.5)).xy * DistortScaleRefractReflect.xy * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
2166 "       float2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
2167 "       float2 ScreenTexCoord = SafeScreenTexCoord + float2(normalize(float3(tex2D(Texture_Normal, TexCoord)) - float3(0.5))).xy * DistortScaleRefractReflect.xy;\n"
2168 "       // FIXME temporary hack to detect the case that the reflection\n"
2169 "       // gets blackened at edges due to leaving the area that contains actual\n"
2170 "       // content.\n"
2171 "       // Remove this 'ack once we have a better way to stop this thing from\n"
2172 "       // 'appening.\n"
2173 "       float f = min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord + float2(0.01, 0.01)).rgb) / 0.05);\n"
2174 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord + float2(0.01, -0.01)).rgb) / 0.05);\n"
2175 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord + float2(-0.01, 0.01)).rgb) / 0.05);\n"
2176 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord + float2(-0.01, -0.01)).rgb) / 0.05);\n"
2177 "       ScreenTexCoord = lerp(SafeScreenTexCoord, ScreenTexCoord, f);\n"
2178 "       gl_FragColor = tex2D(Texture_Refraction, ScreenTexCoord) * RefractColor;\n"
2179 "}\n"
2180 "#endif\n"
2181 "#else // !MODE_REFRACTION\n"
2182 "\n"
2183 "\n"
2184 "\n"
2185 "\n"
2186 "#ifdef MODE_WATER\n"
2187 "#ifdef VERTEX_SHADER\n"
2188 "\n"
2189 "void main\n"
2190 "(\n"
2191 "float4 gl_Vertex : POSITION,\n"
2192 "uniform float4x4 ModelViewProjectionMatrix,\n"
2193 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2194 "uniform float4x4 TexMatrix,\n"
2195 "uniform float3 EyePosition,\n"
2196 "out float4 gl_Position : POSITION,\n"
2197 "out float2 TexCoord : TEXCOORD0,\n"
2198 "out float3 EyeVector : TEXCOORD1,\n"
2199 "out float4 ModelViewProjectionPosition : TEXCOORD2\n"
2200 ")\n"
2201 "{\n"
2202 "       TexCoord = float2(mul(TexMatrix, gl_MultiTexCoord0));\n"
2203 "       float3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
2204 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
2205 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
2206 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
2207 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2208 "       ModelViewProjectionPosition = gl_Position;\n"
2209 "}\n"
2210 "#endif\n"
2211 "\n"
2212 "#ifdef FRAGMENT_SHADER\n"
2213 "void main\n"
2214 "(\n"
2215 "float2 TexCoord : TEXCOORD0,\n"
2216 "float3 EyeVector : TEXCOORD1,\n"
2217 "float4 ModelViewProjectionPosition : TEXCOORD2,\n"
2218 "uniform sampler2D Texture_Normal,\n"
2219 "uniform sampler2D Texture_Refraction,\n"
2220 "uniform sampler2D Texture_Reflection,\n"
2221 "uniform float4 DistortScaleRefractReflect,\n"
2222 "uniform float4 ScreenScaleRefractReflect,\n"
2223 "uniform float4 ScreenCenterRefractReflect,\n"
2224 "uniform float4 RefractColor,\n"
2225 "uniform float4 ReflectColor,\n"
2226 "uniform float ReflectFactor,\n"
2227 "uniform float ReflectOffset,\n"
2228 "out float4 gl_FragColor : COLOR\n"
2229 ")\n"
2230 "{\n"
2231 "       float4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
2232 "       //float4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(float3(tex2D(Texture_Normal, TexCoord)) - float3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
2233 "       float4 SafeScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
2234 "       float4 ScreenTexCoord = SafeScreenTexCoord + float2(normalize(float3(tex2D(Texture_Normal, TexCoord)) - float3(0.5))).xyxy * DistortScaleRefractReflect;\n"
2235 "       // FIXME temporary hack to detect the case that the reflection\n"
2236 "       // gets blackened at edges due to leaving the area that contains actual\n"
2237 "       // content.\n"
2238 "       // Remove this 'ack once we have a better way to stop this thing from\n"
2239 "       // 'appening.\n"
2240 "       float f = min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord.xy + float2(0.01, 0.01)).rgb) / 0.05);\n"
2241 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord.xy + float2(0.01, -0.01)).rgb) / 0.05);\n"
2242 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord.xy + float2(-0.01, 0.01)).rgb) / 0.05);\n"
2243 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord.xy + float2(-0.01, -0.01)).rgb) / 0.05);\n"
2244 "       ScreenTexCoord.xy = lerp(SafeScreenTexCoord.xy, ScreenTexCoord.xy, f);\n"
2245 "       f       = min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord.zw + float2(0.01, 0.01)).rgb) / 0.05);\n"
2246 "       f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord.zw + float2(0.01, -0.01)).rgb) / 0.05);\n"
2247 "       f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord.zw + float2(-0.01, 0.01)).rgb) / 0.05);\n"
2248 "       f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord.zw + float2(-0.01, -0.01)).rgb) / 0.05);\n"
2249 "       ScreenTexCoord.zw = lerp(SafeScreenTexCoord.zw, ScreenTexCoord.zw, f);\n"
2250 "       float Fresnel = pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 2.0) * ReflectFactor + ReflectOffset;\n"
2251 "       gl_FragColor = lerp(tex2D(Texture_Refraction, ScreenTexCoord.xy) * RefractColor, tex2D(Texture_Reflection, ScreenTexCoord.zw) * ReflectColor, Fresnel);\n"
2252 "}\n"
2253 "#endif\n"
2254 "#else // !MODE_WATER\n"
2255 "\n"
2256 "\n"
2257 "\n"
2258 "\n"
2259 "// TODO: get rid of tangentt (texcoord2) and use a crossproduct to regenerate it from tangents (texcoord1) and normal (texcoord3), this would require sending a 4 component texcoord1 with W as 1 or -1 according to which side the texcoord2 should be on\n"
2260 "\n"
2261 "// fragment shader specific:\n"
2262 "#ifdef FRAGMENT_SHADER\n"
2263 "\n"
2264 "#ifdef USEFOG\n"
2265 "float3 FogVertex(float3 surfacecolor, float3 FogColor, float3 EyeVectorModelSpace, float FogPlaneVertexDist, float FogRangeRecip, float FogPlaneViewDist, float FogHeightFade, sampler2D Texture_FogMask, sampler2D Texture_FogHeightTexture)\n"
2266 "{\n"
2267 "       float fogfrac;\n"
2268 "#ifdef USEFOGHEIGHTTEXTURE\n"
2269 "       float4 fogheightpixel = tex2D(Texture_FogHeightTexture, float2(1,1) + float2(FogPlaneVertexDist, FogPlaneViewDist) * (-2.0 * FogHeightFade));\n"
2270 "       fogfrac = fogheightpixel.a;\n"
2271 "       return lerp(fogheightpixel.rgb * FogColor, surfacecolor, tex2D(Texture_FogMask, float2(length(EyeVectorModelSpace)*fogfrac*FogRangeRecip, 0.0)).r);\n"
2272 "#else\n"
2273 "# ifdef USEFOGOUTSIDE\n"
2274 "       fogfrac = min(0.0, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0, min(0.0, FogPlaneVertexDist) * FogHeightFade);\n"
2275 "# else\n"
2276 "       fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0, FogPlaneVertexDist)) * min(1.0, (min(0.0, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);\n"
2277 "# endif\n"
2278 "       return lerp(FogColor, surfacecolor, tex2D(Texture_FogMask, float2(length(EyeVectorModelSpace)*fogfrac*FogRangeRecip, 0.0)).r);\n"
2279 "#endif\n"
2280 "}\n"
2281 "#endif\n"
2282 "\n"
2283 "#ifdef USEOFFSETMAPPING\n"
2284 "float2 OffsetMapping(float2 TexCoord, float OffsetMapping_Scale, float3 EyeVector, sampler2D Texture_Normal)\n"
2285 "{\n"
2286 "#ifdef USEOFFSETMAPPING_RELIEFMAPPING\n"
2287 "       // 14 sample relief mapping: linear search and then binary search\n"
2288 "       // this basically steps forward a small amount repeatedly until it finds\n"
2289 "       // itself inside solid, then jitters forward and back using decreasing\n"
2290 "       // amounts to find the impact\n"
2291 "       //float3 OffsetVector = float3(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * float2(-1, 1), -1);\n"
2292 "       //float3 OffsetVector = float3(normalize(EyeVector.xy) * OffsetMapping_Scale * float2(-1, 1), -1);\n"
2293 "       float3 OffsetVector = float3(normalize(EyeVector).xy * OffsetMapping_Scale * float2(-1, 1), -1);\n"
2294 "       float3 RT = float3(TexCoord, 1);\n"
2295 "       OffsetVector *= 0.1;\n"
2296 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2297 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2298 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2299 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2300 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2301 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2302 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2303 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2304 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2305 "       RT += OffsetVector * (step(tex2D(Texture_Normal, RT.xy).a, RT.z)          - 0.5);\n"
2306 "       RT += OffsetVector * (step(tex2D(Texture_Normal, RT.xy).a, RT.z) * 0.5    - 0.25);\n"
2307 "       RT += OffsetVector * (step(tex2D(Texture_Normal, RT.xy).a, RT.z) * 0.25   - 0.125);\n"
2308 "       RT += OffsetVector * (step(tex2D(Texture_Normal, RT.xy).a, RT.z) * 0.125  - 0.0625);\n"
2309 "       RT += OffsetVector * (step(tex2D(Texture_Normal, RT.xy).a, RT.z) * 0.0625 - 0.03125);\n"
2310 "       return RT.xy;\n"
2311 "#else\n"
2312 "       // 3 sample offset mapping (only 3 samples because of ATI Radeon 9500-9800/X300 limits)\n"
2313 "       // this basically moves forward the full distance, and then backs up based\n"
2314 "       // on height of samples\n"
2315 "       //float2 OffsetVector = float2(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * float2(-1, 1));\n"
2316 "       //float2 OffsetVector = float2(normalize(EyeVector.xy) * OffsetMapping_Scale * float2(-1, 1));\n"
2317 "       float2 OffsetVector = float2(normalize(EyeVector).xy * OffsetMapping_Scale * float2(-1, 1));\n"
2318 "       TexCoord += OffsetVector;\n"
2319 "       OffsetVector *= 0.333;\n"
2320 "       TexCoord -= OffsetVector * tex2D(Texture_Normal, TexCoord).a;\n"
2321 "       TexCoord -= OffsetVector * tex2D(Texture_Normal, TexCoord).a;\n"
2322 "       TexCoord -= OffsetVector * tex2D(Texture_Normal, TexCoord).a;\n"
2323 "       return TexCoord;\n"
2324 "#endif\n"
2325 "}\n"
2326 "#endif // USEOFFSETMAPPING\n"
2327 "\n"
2328 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USESHADOWMAPORTHO)\n"
2329 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D)\n"
2330 "# ifdef USESHADOWMAPORTHO\n"
2331 "#  define GetShadowMapTC2D(dir, ShadowMap_Parameters) (min(dir, ShadowMap_Parameters.xyz))\n"
2332 "# else\n"
2333 "#  ifdef USESHADOWMAPVSDCT\n"
2334 "float3 GetShadowMapTC2D(float3 dir, float4 ShadowMap_Parameters, samplerCUBE Texture_CubeProjection)\n"
2335 "{\n"
2336 "       float3 adir = abs(dir);\n"
2337 "       float2 aparams = ShadowMap_Parameters.xy / max(max(adir.x, adir.y), adir.z);\n"
2338 "       float4 proj = texCUBE(Texture_CubeProjection, dir);\n"
2339 "       return float3(lerp(dir.xy, dir.zz, proj.xy) * aparams.x + proj.zw * ShadowMap_Parameters.z, aparams.y + ShadowMap_Parameters.w);\n"
2340 "}\n"
2341 "#  else\n"
2342 "float3 GetShadowMapTC2D(float3 dir, float4 ShadowMap_Parameters)\n"
2343 "{\n"
2344 "       float3 adir = abs(dir);\n"
2345 "       float ma = adir.z;\n"
2346 "       float4 proj = float4(dir, 2.5);\n"
2347 "       if (adir.x > ma) { ma = adir.x; proj = float4(dir.zyx, 0.5); }\n"
2348 "       if (adir.y > ma) { ma = adir.y; proj = float4(dir.xzy, 1.5); }\n"
2349 "       float2 aparams = ShadowMap_Parameters.xy / ma;\n"
2350 "       return float3(proj.xy * aparams.x + float2(proj.z < 0.0 ? 1.5 : 0.5, proj.w) * ShadowMap_Parameters.z, aparams.y + ShadowMap_Parameters.w);\n"
2351 "}\n"
2352 "#  endif\n"
2353 "# endif\n"
2354 "#endif // defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D)\n"
2355 "\n"
2356 "#ifdef USESHADOWMAPCUBE\n"
2357 "float4 GetShadowMapTCCube(float3 dir, float4 ShadowMap_Parameters)\n"
2358 "{\n"
2359 "    float3 adir = abs(dir);\n"
2360 "    return float4(dir, ShadowMap_Parameters.w + ShadowMap_Parameters.y / max(max(adir.x, adir.y), adir.z));\n"
2361 "}\n"
2362 "#endif\n"
2363 "\n"
2364 "# ifdef USESHADOWMAPRECT\n"
2365 "#ifdef USESHADOWMAPVSDCT\n"
2366 "float ShadowMapCompare(float3 dir, samplerRECT Texture_ShadowMapRect, float4 ShadowMap_Parameters, samplerCUBE Texture_CubeProjection)\n"
2367 "#else\n"
2368 "float ShadowMapCompare(float3 dir, samplerRECT Texture_ShadowMapRect, float4 ShadowMap_Parameters)\n"
2369 "#endif\n"
2370 "{\n"
2371 "#ifdef USESHADOWMAPVSDCT\n"
2372 "       float3 shadowmaptc = GetShadowMapTC2D(dir, ShadowMap_Parameters, Texture_CubeProjection);\n"
2373 "#else\n"
2374 "       float3 shadowmaptc = GetShadowMapTC2D(dir, ShadowMap_Parameters);\n"
2375 "#endif\n"
2376 "       float f;\n"
2377 "#  ifdef USESHADOWSAMPLER\n"
2378 "\n"
2379 "#    ifdef USESHADOWMAPPCF\n"
2380 "#      define texval(x, y) shadow2DRect(Texture_ShadowMapRect, shadowmaptc + float3(x, y, 0.0)).r\n"
2381 "    f = dot(float4(0.25), float4(texval(-0.4, 1.0), texval(-1.0, -0.4), texval(0.4, -1.0), texval(1.0, 0.4)));\n"
2382 "#    else\n"
2383 "    f = shadow2DRect(Texture_ShadowMapRect, shadowmaptc).r;\n"
2384 "#    endif\n"
2385 "\n"
2386 "#  else\n"
2387 "\n"
2388 "#    ifdef USESHADOWMAPPCF\n"
2389 "#      if USESHADOWMAPPCF > 1\n"
2390 "#        define texval(x, y) texRECT(Texture_ShadowMapRect, center + float2(x, y)).r\n"
2391 "    float2 center = shadowmaptc.xy - 0.5, offset = frac(center);\n"
2392 "    float4 row1 = step(shadowmaptc.z, float4(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0), texval( 2.0, -1.0)));\n"
2393 "    float4 row2 = step(shadowmaptc.z, float4(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0), texval( 2.0,  0.0)));\n"
2394 "    float4 row3 = step(shadowmaptc.z, float4(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0), texval( 2.0,  1.0)));\n"
2395 "    float4 row4 = step(shadowmaptc.z, float4(texval(-1.0,  2.0), texval( 0.0,  2.0), texval( 1.0,  2.0), texval( 2.0,  2.0)));\n"
2396 "    float4 cols = row2 + row3 + lerp(row1, row4, offset.y);\n"
2397 "    f = dot(lerp(cols.xyz, cols.yzw, offset.x), float3(1.0/9.0));\n"
2398 "#      else\n"
2399 "#        define texval(x, y) texRECT(Texture_ShadowMapRect, shadowmaptc.xy + float2(x, y)).r\n"
2400 "    float2 offset = frac(shadowmaptc.xy);\n"
2401 "    float3 row1 = step(shadowmaptc.z, float3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n"
2402 "    float3 row2 = step(shadowmaptc.z, float3(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0)));\n"
2403 "    float3 row3 = step(shadowmaptc.z, float3(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0)));\n"
2404 "    float3 cols = row2 + lerp(row1, row3, offset.y);\n"
2405 "    f = dot(lerp(cols.xy, cols.yz, offset.x), float2(0.25));\n"
2406 "#      endif\n"
2407 "#    else\n"
2408 "    f = step(shadowmaptc.z, texRECT(Texture_ShadowMapRect, shadowmaptc.xy).r);\n"
2409 "#    endif\n"
2410 "\n"
2411 "#  endif\n"
2412 "#  ifdef USESHADOWMAPORTHO\n"
2413 "       return lerp(ShadowMap_Parameters.w, 1.0, f);\n"
2414 "#  else\n"
2415 "       return f;\n"
2416 "#  endif\n"
2417 "}\n"
2418 "# endif\n"
2419 "\n"
2420 "# ifdef USESHADOWMAP2D\n"
2421 "#ifdef USESHADOWMAPVSDCT\n"
2422 "float ShadowMapCompare(float3 dir, sampler2D Texture_ShadowMap2D, float4 ShadowMap_Parameters, float2 ShadowMap_TextureScale, samplerCUBE Texture_CubeProjection)\n"
2423 "#else\n"
2424 "float ShadowMapCompare(float3 dir, sampler2D Texture_ShadowMap2D, float4 ShadowMap_Parameters, float2 ShadowMap_TextureScale)\n"
2425 "#endif\n"
2426 "{\n"
2427 "#ifdef USESHADOWMAPVSDCT\n"
2428 "       float3 shadowmaptc = GetShadowMapTC2D(dir, ShadowMap_Parameters, Texture_CubeProjection);\n"
2429 "#else\n"
2430 "       float3 shadowmaptc = GetShadowMapTC2D(dir, ShadowMap_Parameters);\n"
2431 "#endif\n"
2432 "    float f;\n"
2433 "\n"
2434 "#  ifdef USESHADOWSAMPLER\n"
2435 "#    ifdef USESHADOWMAPPCF\n"
2436 "#      define texval(x, y) shadow2D(Texture_ShadowMap2D, float3(center + float2(x, y)*ShadowMap_TextureScale, shadowmaptc.z)).r  \n"
2437 "    float2 center = shadowmaptc.xy*ShadowMap_TextureScale;\n"
2438 "    f = dot(float4(0.25), float4(texval(-0.4, 1.0), texval(-1.0, -0.4), texval(0.4, -1.0), texval(1.0, 0.4)));\n"
2439 "#    else\n"
2440 "    f = shadow2D(Texture_ShadowMap2D, float3(shadowmaptc.xy*ShadowMap_TextureScale, shadowmaptc.z)).r;\n"
2441 "#    endif\n"
2442 "#  else\n"
2443 "#    ifdef USESHADOWMAPPCF\n"
2444 "#     if defined(GL_ARB_texture_gather) || defined(GL_AMD_texture_texture4)\n"
2445 "#      ifdef GL_ARB_texture_gather\n"
2446 "#        define texval(x, y) textureGatherOffset(Texture_ShadowMap2D, center, ivec(x, y))\n"
2447 "#      else\n"
2448 "#        define texval(x, y) texture4(Texture_ShadowMap2D, center + float2(x,y)*ShadowMap_TextureScale)\n"
2449 "#      endif\n"
2450 "    float2 center = shadowmaptc.xy - 0.5, offset = frac(center);\n"
2451 "    center *= ShadowMap_TextureScale;\n"
2452 "    float4 group1 = step(shadowmaptc.z, texval(-1.0, -1.0));\n"
2453 "    float4 group2 = step(shadowmaptc.z, texval( 1.0, -1.0));\n"
2454 "    float4 group3 = step(shadowmaptc.z, texval(-1.0,  1.0));\n"
2455 "    float4 group4 = step(shadowmaptc.z, texval( 1.0,  1.0));\n"
2456 "    float4 cols = float4(group1.rg, group2.rg) + float4(group3.ab, group4.ab) +\n"
2457 "                lerp(float4(group1.ab, group2.ab), float4(group3.rg, group4.rg), offset.y);\n"
2458 "    f = dot(lerp(cols.xyz, cols.yzw, offset.x), float3(1.0/9.0));\n"
2459 "#     else\n"
2460 "#        define texval(x, y) texDepth2D(Texture_ShadowMap2D, center + float2(x, y)*ShadowMap_TextureScale)  \n"
2461 "#      if USESHADOWMAPPCF > 1\n"
2462 "    float2 center = shadowmaptc.xy - 0.5, offset = frac(center);\n"
2463 "    center *= ShadowMap_TextureScale;\n"
2464 "    float4 row1 = step(shadowmaptc.z, float4(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0), texval( 2.0, -1.0)));\n"
2465 "    float4 row2 = step(shadowmaptc.z, float4(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0), texval( 2.0,  0.0)));\n"
2466 "    float4 row3 = step(shadowmaptc.z, float4(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0), texval( 2.0,  1.0)));\n"
2467 "    float4 row4 = step(shadowmaptc.z, float4(texval(-1.0,  2.0), texval( 0.0,  2.0), texval( 1.0,  2.0), texval( 2.0,  2.0)));\n"
2468 "    float4 cols = row2 + row3 + lerp(row1, row4, offset.y);\n"
2469 "    f = dot(lerp(cols.xyz, cols.yzw, offset.x), float3(1.0/9.0));\n"
2470 "#      else\n"
2471 "    float2 center = shadowmaptc.xy*ShadowMap_TextureScale, offset = frac(shadowmaptc.xy);\n"
2472 "    float3 row1 = step(shadowmaptc.z, float3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n"
2473 "    float3 row2 = step(shadowmaptc.z, float3(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0)));\n"
2474 "    float3 row3 = step(shadowmaptc.z, float3(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0)));\n"
2475 "    float3 cols = row2 + lerp(row1, row3, offset.y);\n"
2476 "    f = dot(lerp(cols.xy, cols.yz, offset.x), float2(0.25));\n"
2477 "#      endif\n"
2478 "#     endif\n"
2479 "#    else\n"
2480 "    f = step(shadowmaptc.z, tex2D(Texture_ShadowMap2D, shadowmaptc.xy*ShadowMap_TextureScale).r);\n"
2481 "#    endif\n"
2482 "#  endif\n"
2483 "#  ifdef USESHADOWMAPORTHO\n"
2484 "       return lerp(ShadowMap_Parameters.w, 1.0, f);\n"
2485 "#  else\n"
2486 "       return f;\n"
2487 "#  endif\n"
2488 "}\n"
2489 "# endif\n"
2490 "\n"
2491 "# ifdef USESHADOWMAPCUBE\n"
2492 "float ShadowMapCompare(float3 dir, samplerCUBE Texture_ShadowMapCube, float4 ShadowMap_Parameters)\n"
2493 "{\n"
2494 "    // apply depth texture cubemap as light filter\n"
2495 "    float4 shadowmaptc = GetShadowMapTCCube(dir, ShadowMap_Parameters);\n"
2496 "    float f;\n"
2497 "#  ifdef USESHADOWSAMPLER\n"
2498 "    f = shadowCube(Texture_ShadowMapCube, shadowmaptc).r;\n"
2499 "#  else\n"
2500 "    f = step(shadowmaptc.w, texCUBE(Texture_ShadowMapCube, shadowmaptc.xyz).r);\n"
2501 "#  endif\n"
2502 "    return f;\n"
2503 "}\n"
2504 "# endif\n"
2505 "#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE)\n"
2506 "#endif // FRAGMENT_SHADER\n"
2507 "\n"
2508 "\n"
2509 "\n"
2510 "\n"
2511 "#ifdef MODE_DEFERREDGEOMETRY\n"
2512 "#ifdef VERTEX_SHADER\n"
2513 "void main\n"
2514 "(\n"
2515 "float4 gl_Vertex : POSITION,\n"
2516 "uniform float4x4 ModelViewProjectionMatrix,\n"
2517 "#ifdef USEVERTEXTEXTUREBLEND\n"
2518 "float4 gl_Color : COLOR0,\n"
2519 "#endif\n"
2520 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2521 "float4 gl_MultiTexCoord1 : TEXCOORD1,\n"
2522 "float4 gl_MultiTexCoord2 : TEXCOORD2,\n"
2523 "float4 gl_MultiTexCoord3 : TEXCOORD3,\n"
2524 "uniform float4x4 TexMatrix,\n"
2525 "#ifdef USEVERTEXTEXTUREBLEND\n"
2526 "uniform float4x4 BackgroundTexMatrix,\n"
2527 "#endif\n"
2528 "uniform float4x4 ModelViewMatrix,\n"
2529 "#ifdef USEOFFSETMAPPING\n"
2530 "uniform float3 EyePosition,\n"
2531 "#endif\n"
2532 "out float4 gl_Position : POSITION,\n"
2533 "out float4 gl_FrontColor : COLOR,\n"
2534 "out float4 TexCoordBoth : TEXCOORD0,\n"
2535 "#ifdef USEOFFSETMAPPING\n"
2536 "out float3 EyeVector : TEXCOORD2,\n"
2537 "#endif\n"
2538 "out float3 VectorS : TEXCOORD5, // direction of S texcoord (sometimes crudely called tangent)\n"
2539 "out float3 VectorT : TEXCOORD6, // direction of T texcoord (sometimes crudely called binormal)\n"
2540 "out float3 VectorR : TEXCOORD7 // direction of R texcoord (surface normal)\n"
2541 ")\n"
2542 "{\n"
2543 "       TexCoordBoth = mul(TexMatrix, gl_MultiTexCoord0);\n"
2544 "#ifdef USEVERTEXTEXTUREBLEND\n"
2545 "       gl_FrontColor = gl_Color;\n"
2546 "       TexCoordBoth.zw = float2(Backgroundmul(TexMatrix, gl_MultiTexCoord0));\n"
2547 "#endif\n"
2548 "\n"
2549 "       // transform unnormalized eye direction into tangent space\n"
2550 "#ifdef USEOFFSETMAPPING\n"
2551 "       float3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
2552 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
2553 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
2554 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
2555 "#endif\n"
2556 "\n"
2557 "       VectorS = mul(ModelViewMatrix, float4(gl_MultiTexCoord1.xyz, 0)).xyz;\n"
2558 "       VectorT = mul(ModelViewMatrix, float4(gl_MultiTexCoord2.xyz, 0)).xyz;\n"
2559 "       VectorR = mul(ModelViewMatrix, float4(gl_MultiTexCoord3.xyz, 0)).xyz;\n"
2560 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2561 "}\n"
2562 "#endif // VERTEX_SHADER\n"
2563 "\n"
2564 "#ifdef FRAGMENT_SHADER\n"
2565 "void main\n"
2566 "(\n"
2567 "float4 TexCoordBoth : TEXCOORD0,\n"
2568 "float3 EyeVector : TEXCOORD2,\n"
2569 "float3 VectorS : TEXCOORD5, // direction of S texcoord (sometimes crudely called tangent)\n"
2570 "float3 VectorT : TEXCOORD6, // direction of T texcoord (sometimes crudely called binormal)\n"
2571 "float3 VectorR : TEXCOORD7, // direction of R texcoord (surface normal)\n"
2572 "uniform sampler2D Texture_Normal,\n"
2573 "#ifdef USEALPHAKILL\n"
2574 "uniform sampler2D Texture_Color,\n"
2575 "#endif\n"
2576 "uniform sampler2D Texture_Gloss,\n"
2577 "#ifdef USEVERTEXTEXTUREBLEND\n"
2578 "uniform sampler2D Texture_SecondaryNormal,\n"
2579 "uniform sampler2D Texture_SecondaryGloss,\n"
2580 "#endif\n"
2581 "#ifdef USEOFFSETMAPPING\n"
2582 "uniform float OffsetMapping_Scale,\n"
2583 "#endif\n"
2584 "uniform half SpecularPower,\n"
2585 "out float4 gl_FragColor : COLOR\n"
2586 ")\n"
2587 "{\n"
2588 "       float2 TexCoord = TexCoordBoth.xy;\n"
2589 "#ifdef USEOFFSETMAPPING\n"
2590 "       // apply offsetmapping\n"
2591 "       float2 TexCoordOffset = OffsetMapping(TexCoord, OffsetMapping_Scale, EyeVector, Texture_Normal);\n"
2592 "#define TexCoord TexCoordOffset\n"
2593 "#endif\n"
2594 "\n"
2595 "#ifdef USEALPHAKILL\n"
2596 "       if (tex2D(Texture_Color, TexCoord).a < 0.5)\n"
2597 "               discard;\n"
2598 "#endif\n"
2599 "\n"
2600 "#ifdef USEVERTEXTEXTUREBLEND\n"
2601 "       float alpha = tex2D(Texture_Color, TexCoord).a;\n"
2602 "       float terrainblend = clamp(float(gl_FrontColor.a) * alpha * 2.0 - 0.5, float(0.0), float(1.0));\n"
2603 "       //float terrainblend = min(float(gl_FrontColor.a) * alpha * 2.0, float(1.0));\n"
2604 "       //float terrainblend = float(gl_FrontColor.a) * alpha > 0.5;\n"
2605 "#endif\n"
2606 "\n"
2607 "#ifdef USEVERTEXTEXTUREBLEND\n"
2608 "       float3 surfacenormal = lerp(float3(tex2D(Texture_SecondaryNormal, TexCoord2)), float3(tex2D(Texture_Normal, TexCoord)), terrainblend) - float3(0.5, 0.5, 0.5);\n"
2609 "       float a = lerp(tex2D(Texture_SecondaryGloss, TexCoord2), tex2D(Texture_Gloss, TexCoord).a, terrainblend);\n"
2610 "#else\n"
2611 "       float3 surfacenormal = float3(tex2D(Texture_Normal, TexCoord)) - float3(0.5, 0.5, 0.5);\n"
2612 "       float a = tex2D(Texture_Gloss, TexCoord).a;\n"
2613 "#endif\n"
2614 "\n"
2615 "       gl_FragColor = float4(normalize(surfacenormal.x * VectorS + surfacenormal.y * VectorT + surfacenormal.z * VectorR) * 0.5 + float3(0.5, 0.5, 0.5), 1);\n"
2616 "}\n"
2617 "#endif // FRAGMENT_SHADER\n"
2618 "#else // !MODE_DEFERREDGEOMETRY\n"
2619 "\n"
2620 "\n"
2621 "\n"
2622 "\n"
2623 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
2624 "#ifdef VERTEX_SHADER\n"
2625 "void main\n"
2626 "(\n"
2627 "float4 gl_Vertex : POSITION,\n"
2628 "uniform float4x4 ModelViewProjectionMatrix,\n"
2629 "uniform float4x4 ModelViewMatrix,\n"
2630 "out float4 gl_Position : POSITION,\n"
2631 "out float4 ModelViewPosition : TEXCOORD0\n"
2632 ")\n"
2633 "{\n"
2634 "       ModelViewPosition = mul(ModelViewMatrix, gl_Vertex);\n"
2635 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2636 "}\n"
2637 "#endif // VERTEX_SHADER\n"
2638 "\n"
2639 "#ifdef FRAGMENT_SHADER\n"
2640 "void main\n"
2641 "(\n"
2642 "float2 Pixel : WPOS,\n"
2643 "float4 ModelViewPosition : TEXCOORD0,\n"
2644 "uniform float4x4 ViewToLight,\n"
2645 "uniform float2 ScreenToDepth, // ScreenToDepth = float2(Far / (Far - Near), Far * Near / (Near - Far));\n"
2646 "uniform float3 LightPosition,\n"
2647 "uniform half2 PixelToScreenTexCoord,\n"
2648 "uniform half3 DeferredColor_Ambient,\n"
2649 "uniform half3 DeferredColor_Diffuse,\n"
2650 "#ifdef USESPECULAR\n"
2651 "uniform half3 DeferredColor_Specular,\n"
2652 "uniform half SpecularPower,\n"
2653 "#endif\n"
2654 "uniform sampler2D Texture_Attenuation,\n"
2655 "uniform sampler2D Texture_ScreenDepth,\n"
2656 "uniform sampler2D Texture_ScreenNormalMap,\n"
2657 "\n"
2658 "#ifdef USECUBEFILTER\n"
2659 "uniform samplerCUBE Texture_Cube,\n"
2660 "#endif\n"
2661 "\n"
2662 "#ifdef USESHADOWMAPRECT\n"
2663 "# ifdef USESHADOWSAMPLER\n"
2664 "uniform samplerRECTShadow Texture_ShadowMapRect,\n"
2665 "# else\n"
2666 "uniform samplerRECT Texture_ShadowMapRect,\n"
2667 "# endif\n"
2668 "#endif\n"
2669 "\n"
2670 "#ifdef USESHADOWMAP2D\n"
2671 "# ifdef USESHADOWSAMPLER\n"
2672 "uniform sampler2DShadow Texture_ShadowMap2D,\n"
2673 "# else\n"
2674 "uniform sampler2D Texture_ShadowMap2D,\n"
2675 "# endif\n"
2676 "#endif\n"
2677 "\n"
2678 "#ifdef USESHADOWMAPVSDCT\n"
2679 "uniform samplerCUBE Texture_CubeProjection,\n"
2680 "#endif\n"
2681 "\n"
2682 "#ifdef USESHADOWMAPCUBE\n"
2683 "# ifdef USESHADOWSAMPLER\n"
2684 "uniform samplerCUBEShadow Texture_ShadowMapCube,\n"
2685 "# else\n"
2686 "uniform samplerCUBE Texture_ShadowMapCube,\n"
2687 "# endif\n"
2688 "#endif\n"
2689 "\n"
2690 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D) || defined(USESHADOWMAPCUBE)\n"
2691 "uniform float2 ShadowMap_TextureScale,\n"
2692 "uniform float4 ShadowMap_Parameters,\n"
2693 "#endif\n"
2694 "\n"
2695 "out float4 gl_FragData0 : COLOR0,\n"
2696 "out float4 gl_FragData1 : COLOR1\n"
2697 ")\n"
2698 "{\n"
2699 "       // calculate viewspace pixel position\n"
2700 "       float2 ScreenTexCoord = Pixel * PixelToScreenTexCoord;\n"
2701 "       //ScreenTexCoord.y = ScreenTexCoord.y * -1 + 1; // Cg is opposite?\n"
2702 "       float3 position;\n"
2703 "       position.z = ScreenToDepth.y / (texDepth2D(Texture_ScreenDepth, ScreenTexCoord) + ScreenToDepth.x);\n"
2704 "       position.xy = ModelViewPosition.xy * (position.z / ModelViewPosition.z);\n"
2705 "       // decode viewspace pixel normal\n"
2706 "       half4 normalmap = tex2D(Texture_ScreenNormalMap, ScreenTexCoord);\n"
2707 "       half3 surfacenormal = normalize(normalmap.rgb - half3(0.5,0.5,0.5));\n"
2708 "       // surfacenormal = pixel normal in viewspace\n"
2709 "       // LightVector = pixel to light in viewspace\n"
2710 "       // CubeVector = position in lightspace\n"
2711 "       // eyevector = pixel to view in viewspace\n"
2712 "       float3 CubeVector = float3(mul(ViewToLight, float4(position,1)));\n"
2713 "       half fade = half(tex2D(Texture_Attenuation, float2(length(CubeVector), 0.0)));\n"
2714 "#ifdef USEDIFFUSE\n"
2715 "       // calculate diffuse shading\n"
2716 "       half3 lightnormal = half3(normalize(LightPosition - position));\n"
2717 "       half diffuse = half(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
2718 "#endif\n"
2719 "#ifdef USESPECULAR\n"
2720 "       // calculate directional shading\n"
2721 "       float3 eyevector = position * -1.0;\n"
2722 "#  ifdef USEEXACTSPECULARMATH\n"
2723 "       half specular = pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(eyevector)))*-1.0, 0.0)), SpecularPower * normalmap.a);\n"
2724 "#  else\n"
2725 "       half3 specularnormal = normalize(lightnormal + half3(normalize(eyevector)));\n"
2726 "       half specular = pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * normalmap.a);\n"
2727 "#  endif\n"
2728 "#endif\n"
2729 "\n"
2730 "#if defined(USESHADOWMAP2D) || defined(USESHADOWMAPRECT) || defined(USESHADOWMAPCUBE)\n"
2731 "       fade *= ShadowMapCompare(CubeVector,\n"
2732 "# if defined(USESHADOWMAP2D)\n"
2733 "Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale\n"
2734 "# endif\n"
2735 "# if defined(USESHADOWMAPRECT)\n"
2736 "Texture_ShadowMapRect, ShadowMap_Parameters\n"
2737 "# endif\n"
2738 "# if defined(USESHADOWMAPCUBE)\n"
2739 "Texture_ShadowMapCube, ShadowMap_Parameters\n"
2740 "# endif\n"
2741 "\n"
2742 "#ifdef USESHADOWMAPVSDCT\n"
2743 ", Texture_CubeProjection\n"
2744 "#endif\n"
2745 "       );\n"
2746 "#endif\n"
2747 "\n"
2748 "#ifdef USEDIFFUSE\n"
2749 "       gl_FragData0 = float4((DeferredColor_Ambient + DeferredColor_Diffuse * diffuse) * fade, 1.0);\n"
2750 "#else\n"
2751 "       gl_FragData0 = float4(DeferredColor_Ambient * fade, 1.0);\n"
2752 "#endif\n"
2753 "#ifdef USESPECULAR\n"
2754 "       gl_FragData1 = float4(DeferredColor_Specular * (specular * fade), 1.0);\n"
2755 "#else\n"
2756 "       gl_FragData1 = float4(0.0, 0.0, 0.0, 1.0);\n"
2757 "#endif\n"
2758 "\n"
2759 "# ifdef USECUBEFILTER\n"
2760 "       float3 cubecolor = texCUBE(Texture_Cube, CubeVector).rgb;\n"
2761 "       gl_FragData0.rgb *= cubecolor;\n"
2762 "       gl_FragData1.rgb *= cubecolor;\n"
2763 "# endif\n"
2764 "}\n"
2765 "#endif // FRAGMENT_SHADER\n"
2766 "#else // !MODE_DEFERREDLIGHTSOURCE\n"
2767 "\n"
2768 "\n"
2769 "\n"
2770 "\n"
2771 "#ifdef VERTEX_SHADER\n"
2772 "void main\n"
2773 "(\n"
2774 "float4 gl_Vertex : POSITION,\n"
2775 "uniform float4x4 ModelViewProjectionMatrix,\n"
2776 "#if defined(USEVERTEXTEXTUREBLEND) || defined(MODE_VERTEXCOLOR)\n"
2777 "float4 gl_Color : COLOR0,\n"
2778 "#endif\n"
2779 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2780 "float4 gl_MultiTexCoord1 : TEXCOORD1,\n"
2781 "float4 gl_MultiTexCoord2 : TEXCOORD2,\n"
2782 "float4 gl_MultiTexCoord3 : TEXCOORD3,\n"
2783 "float4 gl_MultiTexCoord4 : TEXCOORD4,\n"
2784 "\n"
2785 "uniform float3 EyePosition,\n"
2786 "uniform float4x4 TexMatrix,\n"
2787 "#ifdef USEVERTEXTEXTUREBLEND\n"
2788 "uniform float4x4 BackgroundTexMatrix,\n"
2789 "#endif\n"
2790 "#ifdef MODE_LIGHTSOURCE\n"
2791 "uniform float4x4 ModelToLight,\n"
2792 "#endif\n"
2793 "#ifdef MODE_LIGHTSOURCE\n"
2794 "uniform float3 LightPosition,\n"
2795 "#endif\n"
2796 "#ifdef MODE_LIGHTDIRECTION\n"
2797 "uniform float3 LightDir,\n"
2798 "#endif\n"
2799 "uniform float4 FogPlane,\n"
2800 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
2801 "uniform float3 LightPosition,\n"
2802 "#endif\n"
2803 "#ifdef USESHADOWMAPORTHO\n"
2804 "uniform float4x4 ShadowMapMatrix,\n"
2805 "#endif\n"
2806 "\n"
2807 "out float4 gl_FrontColor : COLOR,\n"
2808 "out float4 TexCoordBoth : TEXCOORD0,\n"
2809 "#ifdef USELIGHTMAP\n"
2810 "out float2 TexCoordLightmap : TEXCOORD1,\n"
2811 "#endif\n"
2812 "#ifdef USEEYEVECTOR\n"
2813 "out float3 EyeVector : TEXCOORD2,\n"
2814 "#endif\n"
2815 "#ifdef USEREFLECTION\n"
2816 "out float4 ModelViewProjectionPosition : TEXCOORD3,\n"
2817 "#endif\n"
2818 "#ifdef USEFOG\n"
2819 "out float4 EyeVectorModelSpaceFogPlaneVertexDist : TEXCOORD4,\n"
2820 "#endif\n"
2821 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_LIGHTDIRECTION)\n"
2822 "out float3 LightVector : TEXCOORD1,\n"
2823 "#endif\n"
2824 "#ifdef MODE_LIGHTSOURCE\n"
2825 "out float3 CubeVector : TEXCOORD3,\n"
2826 "#endif\n"
2827 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY) || defined(USEREFLECTCUBE)\n"
2828 "out float3 VectorS : TEXCOORD5, // direction of S texcoord (sometimes crudely called tangent)\n"
2829 "out float3 VectorT : TEXCOORD6, // direction of T texcoord (sometimes crudely called binormal)\n"
2830 "out float3 VectorR : TEXCOORD7, // direction of R texcoord (surface normal)\n"
2831 "#endif\n"
2832 "#ifdef USESHADOWMAPORTHO\n"
2833 "out float3 ShadowMapTC : TEXCOORD3, // CONFLICTS WITH USEREFLECTION!\n"
2834 "#endif\n"
2835 "out float4 gl_Position : POSITION\n"
2836 ")\n"
2837 "{\n"
2838 "#if defined(MODE_VERTEXCOLOR) || defined(USEVERTEXTEXTUREBLEND)\n"
2839 "       gl_FrontColor = gl_Color;\n"
2840 "#endif\n"
2841 "       // copy the surface texcoord\n"
2842 "       TexCoordBoth = mul(TexMatrix, gl_MultiTexCoord0);\n"
2843 "#ifdef USEVERTEXTEXTUREBLEND\n"
2844 "       TexCoordBoth.zw = mul(BackgroundTexMatrix, gl_MultiTexCoord0).xy;\n"
2845 "#endif\n"
2846 "#ifdef USELIGHTMAP\n"
2847 "       TexCoordLightmap = float2(gl_MultiTexCoord4);\n"
2848 "#endif\n"
2849 "\n"
2850 "#ifdef MODE_LIGHTSOURCE\n"
2851 "       // transform vertex position into light attenuation/cubemap space\n"
2852 "       // (-1 to +1 across the light box)\n"
2853 "       CubeVector = float3(mul(ModelToLight, gl_Vertex));\n"
2854 "\n"
2855 "# ifdef USEDIFFUSE\n"
2856 "       // transform unnormalized light direction into tangent space\n"
2857 "       // (we use unnormalized to ensure that it interpolates correctly and then\n"
2858 "       //  normalize it per pixel)\n"
2859 "       float3 lightminusvertex = LightPosition - gl_Vertex.xyz;\n"
2860 "       LightVector.x = dot(lightminusvertex, gl_MultiTexCoord1.xyz);\n"
2861 "       LightVector.y = dot(lightminusvertex, gl_MultiTexCoord2.xyz);\n"
2862 "       LightVector.z = dot(lightminusvertex, gl_MultiTexCoord3.xyz);\n"
2863 "# endif\n"
2864 "#endif\n"
2865 "\n"
2866 "#if defined(MODE_LIGHTDIRECTION) && defined(USEDIFFUSE)\n"
2867 "       LightVector.x = dot(LightDir, gl_MultiTexCoord1.xyz);\n"
2868 "       LightVector.y = dot(LightDir, gl_MultiTexCoord2.xyz);\n"
2869 "       LightVector.z = dot(LightDir, gl_MultiTexCoord3.xyz);\n"
2870 "#endif\n"
2871 "\n"
2872 "       // transform unnormalized eye direction into tangent space\n"
2873 "#ifdef USEEYEVECTOR\n"
2874 "       float3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
2875 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
2876 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
2877 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
2878 "#endif\n"
2879 "\n"
2880 "#ifdef USEFOG\n"
2881 "       EyeVectorModelSpaceFogPlaneVertexDist.xyz = EyePosition - gl_Vertex.xyz;\n"
2882 "       EyeVectorModelSpaceFogPlaneVertexDist.w = dot(FogPlane, gl_Vertex);\n"
2883 "#endif\n"
2884 "\n"
2885 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
2886 "       VectorS = gl_MultiTexCoord1.xyz;\n"
2887 "       VectorT = gl_MultiTexCoord2.xyz;\n"
2888 "       VectorR = gl_MultiTexCoord3.xyz;\n"
2889 "#endif\n"
2890 "\n"
2891 "       // transform vertex to camera space, using ftransform to match non-VS rendering\n"
2892 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2893 "\n"
2894 "#ifdef USESHADOWMAPORTHO\n"
2895 "       ShadowMapTC = float3(mul(ShadowMapMatrix, gl_Position));\n"
2896 "#endif\n"
2897 "\n"
2898 "#ifdef USEREFLECTION\n"
2899 "       ModelViewProjectionPosition = gl_Position;\n"
2900 "#endif\n"
2901 "}\n"
2902 "#endif // VERTEX_SHADER\n"
2903 "\n"
2904 "\n"
2905 "\n"
2906 "\n"
2907 "#ifdef FRAGMENT_SHADER\n"
2908 "void main\n"
2909 "(\n"
2910 "#ifdef USEDEFERREDLIGHTMAP\n"
2911 "float2 Pixel : WPOS,\n"
2912 "#endif\n"
2913 "float4 gl_FrontColor : COLOR,\n"
2914 "float4 TexCoordBoth : TEXCOORD0,\n"
2915 "#ifdef USELIGHTMAP\n"
2916 "float2 TexCoordLightmap : TEXCOORD1,\n"
2917 "#endif\n"
2918 "#ifdef USEEYEVECTOR\n"
2919 "float3 EyeVector : TEXCOORD2,\n"
2920 "#endif\n"
2921 "#ifdef USEREFLECTION\n"
2922 "float4 ModelViewProjectionPosition : TEXCOORD3,\n"
2923 "#endif\n"
2924 "#ifdef USEFOG\n"
2925 "float4 EyeVectorModelSpaceFogPlaneVertexDist : TEXCOORD4,\n"
2926 "#endif\n"
2927 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_LIGHTDIRECTION)\n"
2928 "float3 LightVector : TEXCOORD1,\n"
2929 "#endif\n"
2930 "#ifdef MODE_LIGHTSOURCE\n"
2931 "float3 CubeVector : TEXCOORD3,\n"
2932 "#endif\n"
2933 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
2934 "float4 ModelViewPosition : TEXCOORD0,\n"
2935 "#endif\n"
2936 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY) || defined(USEREFLECTCUBE)\n"
2937 "float3 VectorS : TEXCOORD5, // direction of S texcoord (sometimes crudely called tangent)\n"
2938 "float3 VectorT : TEXCOORD6, // direction of T texcoord (sometimes crudely called binormal)\n"
2939 "float3 VectorR : TEXCOORD7, // direction of R texcoord (surface normal)\n"
2940 "#endif\n"
2941 "#ifdef USESHADOWMAPORTHO\n"
2942 "float3 ShadowMapTC : TEXCOORD3, // CONFLICTS WITH USEREFLECTION!\n"
2943 "#endif\n"
2944 "\n"
2945 "uniform sampler2D Texture_Normal,\n"
2946 "uniform sampler2D Texture_Color,\n"
2947 "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
2948 "uniform sampler2D Texture_Gloss,\n"
2949 "#endif\n"
2950 "#ifdef USEGLOW\n"
2951 "uniform sampler2D Texture_Glow,\n"
2952 "#endif\n"
2953 "#ifdef USEVERTEXTEXTUREBLEND\n"
2954 "uniform sampler2D Texture_SecondaryNormal,\n"
2955 "uniform sampler2D Texture_SecondaryColor,\n"
2956 "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
2957 "uniform sampler2D Texture_SecondaryGloss,\n"
2958 "#endif\n"
2959 "#ifdef USEGLOW\n"
2960 "uniform sampler2D Texture_SecondaryGlow,\n"
2961 "#endif\n"
2962 "#endif\n"
2963 "#ifdef USECOLORMAPPING\n"
2964 "uniform sampler2D Texture_Pants,\n"
2965 "uniform sampler2D Texture_Shirt,\n"
2966 "#endif\n"
2967 "#ifdef USEFOG\n"
2968 "uniform sampler2D Texture_FogHeightTexture,\n"
2969 "uniform sampler2D Texture_FogMask,\n"
2970 "#endif\n"
2971 "#ifdef USELIGHTMAP\n"
2972 "uniform sampler2D Texture_Lightmap,\n"
2973 "#endif\n"
2974 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
2975 "uniform sampler2D Texture_Deluxemap,\n"
2976 "#endif\n"
2977 "#ifdef USEREFLECTION\n"
2978 "uniform sampler2D Texture_Reflection,\n"
2979 "#endif\n"
2980 "\n"
2981 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
2982 "uniform sampler2D Texture_ScreenDepth,\n"
2983 "uniform sampler2D Texture_ScreenNormalMap,\n"
2984 "#endif\n"
2985 "#ifdef USEDEFERREDLIGHTMAP\n"
2986 "uniform sampler2D Texture_ScreenDiffuse,\n"
2987 "uniform sampler2D Texture_ScreenSpecular,\n"
2988 "#endif\n"
2989 "\n"
2990 "#ifdef USECOLORMAPPING\n"
2991 "uniform half3 Color_Pants,\n"
2992 "uniform half3 Color_Shirt,\n"
2993 "#endif\n"
2994 "#ifdef USEFOG\n"
2995 "uniform float3 FogColor,\n"
2996 "uniform float FogRangeRecip,\n"
2997 "uniform float FogPlaneViewDist,\n"
2998 "uniform float FogHeightFade,\n"
2999 "#endif\n"
3000 "\n"
3001 "#ifdef USEOFFSETMAPPING\n"
3002 "uniform float OffsetMapping_Scale,\n"
3003 "#endif\n"
3004 "\n"
3005 "#ifdef USEDEFERREDLIGHTMAP\n"
3006 "uniform half2 PixelToScreenTexCoord,\n"
3007 "uniform half3 DeferredMod_Diffuse,\n"
3008 "uniform half3 DeferredMod_Specular,\n"
3009 "#endif\n"
3010 "uniform half3 Color_Ambient,\n"
3011 "uniform half3 Color_Diffuse,\n"
3012 "uniform half3 Color_Specular,\n"
3013 "uniform half SpecularPower,\n"
3014 "#ifdef USEGLOW\n"
3015 "uniform half3 Color_Glow,\n"
3016 "#endif\n"
3017 "uniform half Alpha,\n"
3018 "#ifdef USEREFLECTION\n"
3019 "uniform float4 DistortScaleRefractReflect,\n"
3020 "uniform float4 ScreenScaleRefractReflect,\n"
3021 "uniform float4 ScreenCenterRefractReflect,\n"
3022 "uniform half4 ReflectColor,\n"
3023 "#endif\n"
3024 "#ifdef USEREFLECTCUBE\n"
3025 "uniform float4x4 ModelToReflectCube,\n"
3026 "uniform sampler2D Texture_ReflectMask,\n"
3027 "uniform samplerCUBE Texture_ReflectCube,\n"
3028 "#endif\n"
3029 "#ifdef MODE_LIGHTDIRECTION\n"
3030 "uniform half3 LightColor,\n"
3031 "#endif\n"
3032 "#ifdef MODE_LIGHTSOURCE\n"
3033 "uniform half3 LightColor,\n"
3034 "#endif\n"
3035 "\n"
3036 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE)\n"
3037 "uniform sampler2D Texture_Attenuation,\n"
3038 "uniform samplerCUBE Texture_Cube,\n"
3039 "#endif\n"
3040 "\n"
3041 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USESHADOWMAPORTHO)\n"
3042 "\n"
3043 "#ifdef USESHADOWMAPRECT\n"
3044 "# ifdef USESHADOWSAMPLER\n"
3045 "uniform samplerRECTShadow Texture_ShadowMapRect,\n"
3046 "# else\n"
3047 "uniform samplerRECT Texture_ShadowMapRect,\n"
3048 "# endif\n"
3049 "#endif\n"
3050 "\n"
3051 "#ifdef USESHADOWMAP2D\n"
3052 "# ifdef USESHADOWSAMPLER\n"
3053 "uniform sampler2DShadow Texture_ShadowMap2D,\n"
3054 "# else\n"
3055 "uniform sampler2D Texture_ShadowMap2D,\n"
3056 "# endif\n"
3057 "#endif\n"
3058 "\n"
3059 "#ifdef USESHADOWMAPVSDCT\n"
3060 "uniform samplerCUBE Texture_CubeProjection,\n"
3061 "#endif\n"
3062 "\n"
3063 "#ifdef USESHADOWMAPCUBE\n"
3064 "# ifdef USESHADOWSAMPLER\n"
3065 "uniform samplerCUBEShadow Texture_ShadowMapCube,\n"
3066 "# else\n"
3067 "uniform samplerCUBE Texture_ShadowMapCube,\n"
3068 "# endif\n"
3069 "#endif\n"
3070 "\n"
3071 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D) || defined(USESHADOWMAPCUBE)\n"
3072 "uniform float2 ShadowMap_TextureScale,\n"
3073 "uniform float4 ShadowMap_Parameters,\n"
3074 "#endif\n"
3075 "#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE) && !defined(USESHADOWMAPORTHO)\n"
3076 "\n"
3077 "out float4 gl_FragColor : COLOR\n"
3078 ")\n"
3079 "{\n"
3080 "       float2 TexCoord = TexCoordBoth.xy;\n"
3081 "#ifdef USEVERTEXTEXTUREBLEND\n"
3082 "       float2 TexCoord2 = TexCoordBoth.zw;\n"
3083 "#endif\n"
3084 "#ifdef USEOFFSETMAPPING\n"
3085 "       // apply offsetmapping\n"
3086 "       float2 TexCoordOffset = OffsetMapping(TexCoord, OffsetMapping_Scale, EyeVector, Texture_Normal);\n"
3087 "#define TexCoord TexCoordOffset\n"
3088 "#endif\n"
3089 "\n"
3090 "       // combine the diffuse textures (base, pants, shirt)\n"
3091 "       half4 color = half4(tex2D(Texture_Color, TexCoord));\n"
3092 "#ifdef USEALPHAKILL\n"
3093 "       if (color.a < 0.5)\n"
3094 "               discard;\n"
3095 "#endif\n"
3096 "       color.a *= Alpha;\n"
3097 "#ifdef USECOLORMAPPING\n"
3098 "       color.rgb += half3(tex2D(Texture_Pants, TexCoord)) * Color_Pants + half3(tex2D(Texture_Shirt, TexCoord)) * Color_Shirt;\n"
3099 "#endif\n"
3100 "#ifdef USEVERTEXTEXTUREBLEND\n"
3101 "       float terrainblend = clamp(half(gl_FrontColor.a) * color.a * 2.0 - 0.5, half(0.0), half(1.0));\n"
3102 "       //half terrainblend = min(half(gl_FrontColor.a) * color.a * 2.0, half(1.0));\n"
3103 "       //half terrainblend = half(gl_FrontColor.a) * color.a > 0.5;\n"
3104 "       color.rgb = half3(lerp(float3(tex2D(Texture_SecondaryColor, TexCoord2)), float3(color.rgb), terrainblend));\n"
3105 "       color.a = 1.0;\n"
3106 "       //color = lerp(half4(1, 0, 0, 1), color, terrainblend);\n"
3107 "#endif\n"
3108 "\n"
3109 "       // get the surface normal\n"
3110 "#ifdef USEVERTEXTEXTUREBLEND\n"
3111 "       half3 surfacenormal = normalize(half3(lerp(float3(tex2D(Texture_SecondaryNormal, TexCoord2)), float3(tex2D(Texture_Normal, TexCoord)), terrainblend)) - half3(0.5, 0.5, 0.5));\n"
3112 "#else\n"
3113 "       half3 surfacenormal = normalize(half3(tex2D(Texture_Normal, TexCoord)) - half3(0.5, 0.5, 0.5));\n"
3114 "#endif\n"
3115 "\n"
3116 "       // get the material colors\n"
3117 "       half3 diffusetex = color.rgb;\n"
3118 "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
3119 "# ifdef USEVERTEXTEXTUREBLEND\n"
3120 "       half4 glosstex = half4(lerp(float4(tex2D(Texture_SecondaryGloss, TexCoord2)), float4(tex2D(Texture_Gloss, TexCoord)), terrainblend));\n"
3121 "# else\n"
3122 "       half4 glosstex = half4(tex2D(Texture_Gloss, TexCoord));\n"
3123 "# endif\n"
3124 "#endif\n"
3125 "\n"
3126 "#ifdef USEREFLECTCUBE\n"
3127 "       float3 TangentReflectVector = reflect(-EyeVector, surfacenormal);\n"
3128 "       float3 ModelReflectVector = TangentReflectVector.x * VectorS + TangentReflectVector.y * VectorT + TangentReflectVector.z * VectorR;\n"
3129 "       float3 ReflectCubeTexCoord = float3(mul(ModelToReflectCube, float4(ModelReflectVector, 0)));\n"
3130 "       diffusetex += half3(tex2D(Texture_ReflectMask, TexCoord)) * half3(texCUBE(Texture_ReflectCube, ReflectCubeTexCoord));\n"
3131 "#endif\n"
3132 "\n"
3133 "\n"
3134 "\n"
3135 "\n"
3136 "#ifdef MODE_LIGHTSOURCE\n"
3137 "       // light source\n"
3138 "#ifdef USEDIFFUSE\n"
3139 "       half3 lightnormal = half3(normalize(LightVector));\n"
3140 "       half diffuse = half(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
3141 "       color.rgb = diffusetex * (Color_Ambient + diffuse * Color_Diffuse);\n"
3142 "#ifdef USESPECULAR\n"
3143 "#ifdef USEEXACTSPECULARMATH\n"
3144 "       half specular = pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a);\n"
3145 "#else\n"
3146 "       half3 specularnormal = normalize(lightnormal + half3(normalize(EyeVector)));\n"
3147 "       half specular = pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a);\n"
3148 "#endif\n"
3149 "       color.rgb += glosstex.rgb * (specular * Color_Specular);\n"
3150 "#endif\n"
3151 "#else\n"
3152 "       color.rgb = diffusetex * Color_Ambient;\n"
3153 "#endif\n"
3154 "       color.rgb *= LightColor;\n"
3155 "       color.rgb *= half(tex2D(Texture_Attenuation, float2(length(CubeVector), 0.0)));\n"
3156 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAPCUBE) || defined(USESHADOWMAP2D)\n"
3157 "       color.rgb *= ShadowMapCompare(CubeVector,\n"
3158 "# if defined(USESHADOWMAP2D)\n"
3159 "Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale\n"
3160 "# endif\n"
3161 "# if defined(USESHADOWMAPRECT)\n"
3162 "Texture_ShadowMapRect, ShadowMap_Parameters\n"
3163 "# endif\n"
3164 "# if defined(USESHADOWMAPCUBE)\n"
3165 "Texture_ShadowMapCube, ShadowMap_Parameters\n"
3166 "# endif\n"
3167 "\n"
3168 "#ifdef USESHADOWMAPVSDCT\n"
3169 ", Texture_CubeProjection\n"
3170 "#endif\n"
3171 "       );\n"
3172 "\n"
3173 "#endif\n"
3174 "# ifdef USECUBEFILTER\n"
3175 "       color.rgb *= half3(texCUBE(Texture_Cube, CubeVector));\n"
3176 "# endif\n"
3177 "#endif // MODE_LIGHTSOURCE\n"
3178 "\n"
3179 "\n"
3180 "\n"
3181 "\n"
3182 "#ifdef MODE_LIGHTDIRECTION\n"
3183 "#define SHADING\n"
3184 "#ifdef USEDIFFUSE\n"
3185 "       half3 lightnormal = half3(normalize(LightVector));\n"
3186 "#endif\n"
3187 "#define lightcolor LightColor\n"
3188 "#endif // MODE_LIGHTDIRECTION\n"
3189 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
3190 "#define SHADING\n"
3191 "       // deluxemap lightmapping using light vectors in modelspace (q3map2 -light -deluxe)\n"
3192 "       half3 lightnormal_modelspace = half3(tex2D(Texture_Deluxemap, TexCoordLightmap)) * 2.0 + half3(-1.0, -1.0, -1.0);\n"
3193 "       half3 lightcolor = half3(tex2D(Texture_Lightmap, TexCoordLightmap));\n"
3194 "       // convert modelspace light vector to tangentspace\n"
3195 "       half3 lightnormal;\n"
3196 "       lightnormal.x = dot(lightnormal_modelspace, half3(VectorS));\n"
3197 "       lightnormal.y = dot(lightnormal_modelspace, half3(VectorT));\n"
3198 "       lightnormal.z = dot(lightnormal_modelspace, half3(VectorR));\n"
3199 "       // calculate directional shading (and undoing the existing angle attenuation on the lightmap by the division)\n"
3200 "       // note that q3map2 is too stupid to calculate proper surface normals when q3map_nonplanar\n"
3201 "       // is used (the lightmap and deluxemap coords correspond to virtually random coordinates\n"
3202 "       // on that luxel, and NOT to its center, because recursive triangle subdivision is used\n"
3203 "       // to map the luxels to coordinates on the draw surfaces), which also causes\n"
3204 "       // deluxemaps to be wrong because light contributions from the wrong side of the surface\n"
3205 "       // are added up. To prevent divisions by zero or strong exaggerations, a max()\n"
3206 "       // nudge is done here at expense of some additional fps. This is ONLY needed for\n"
3207 "       // deluxemaps, tangentspace deluxemap avoid this problem by design.\n"
3208 "       lightcolor *= 1.0 / max(0.25, lightnormal.z);\n"
3209 "#endif // MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
3210 "#ifdef MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
3211 "#define SHADING\n"
3212 "       // deluxemap lightmapping using light vectors in tangentspace (hmap2 -light)\n"
3213 "       half3 lightnormal = half3(tex2D(Texture_Deluxemap, TexCoordLightmap)) * 2.0 + half3(-1.0, -1.0, -1.0);\n"
3214 "       half3 lightcolor = half3(tex2D(Texture_Lightmap, TexCoordLightmap));\n"
3215 "#endif\n"
3216 "\n"
3217 "\n"
3218 "\n"
3219 "\n"
3220 "#ifdef MODE_LIGHTMAP\n"
3221 "       color.rgb = diffusetex * (Color_Ambient + half3(tex2D(Texture_Lightmap, TexCoordLightmap)) * Color_Diffuse);\n"
3222 "#endif // MODE_LIGHTMAP\n"
3223 "#ifdef MODE_VERTEXCOLOR\n"
3224 "       color.rgb = diffusetex * (Color_Ambient + half3(gl_FrontColor.rgb) * Color_Diffuse);\n"
3225 "#endif // MODE_VERTEXCOLOR\n"
3226 "#ifdef MODE_FLATCOLOR\n"
3227 "       color.rgb = diffusetex * Color_Ambient;\n"
3228 "#endif // MODE_FLATCOLOR\n"
3229 "\n"
3230 "\n"
3231 "\n"
3232 "\n"
3233 "#ifdef SHADING\n"
3234 "# ifdef USEDIFFUSE\n"
3235 "       half diffuse = half(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
3236 "#  ifdef USESPECULAR\n"
3237 "#   ifdef USEEXACTSPECULARMATH\n"
3238 "       half specular = pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a);\n"
3239 "#   else\n"
3240 "       half3 specularnormal = normalize(lightnormal + half3(normalize(EyeVector)));\n"
3241 "       half specular = pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a);\n"
3242 "#   endif\n"
3243 "       color.rgb = diffusetex * Color_Ambient + (diffusetex * Color_Diffuse * diffuse + glosstex.rgb * Color_Specular * specular) * lightcolor;\n"
3244 "#  else\n"
3245 "       color.rgb = diffusetex * (Color_Ambient + Color_Diffuse * diffuse * lightcolor);\n"
3246 "#  endif\n"
3247 "# else\n"
3248 "       color.rgb = diffusetex * Color_Ambient;\n"
3249 "# endif\n"
3250 "#endif\n"
3251 "\n"
3252 "#ifdef USESHADOWMAPORTHO\n"
3253 "       color.rgb *= ShadowMapCompare(ShadowMapTC,\n"
3254 "# if defined(USESHADOWMAP2D)\n"
3255 "Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale\n"
3256 "# endif\n"
3257 "# if defined(USESHADOWMAPRECT)\n"
3258 "Texture_ShadowMapRect, ShadowMap_Parameters\n"
3259 "# endif\n"
3260 "       );\n"
3261 "#endif\n"
3262 "\n"
3263 "#ifdef USEDEFERREDLIGHTMAP\n"
3264 "       float2 ScreenTexCoord = Pixel * PixelToScreenTexCoord;\n"
3265 "       color.rgb += diffusetex * half3(tex2D(Texture_ScreenDiffuse, ScreenTexCoord)) * DeferredMod_Diffuse;\n"
3266 "       color.rgb += glosstex.rgb * half3(tex2D(Texture_ScreenSpecular, ScreenTexCoord)) * DeferredMod_Specular;\n"
3267 "#endif\n"
3268 "\n"
3269 "#ifdef USEGLOW\n"
3270 "#ifdef USEVERTEXTEXTUREBLEND\n"
3271 "       color.rgb += lerp(half3(tex2D(Texture_SecondaryGlow, TexCoord2)), half3(tex2D(Texture_Glow, TexCoord)), terrainblend) * Color_Glow;\n"
3272 "#else\n"
3273 "       color.rgb += half3(tex2D(Texture_Glow, TexCoord)) * Color_Glow;\n"
3274 "#endif\n"
3275 "#endif\n"
3276 "\n"
3277 "#ifdef USEFOG\n"
3278 "       color.rgb = FogVertex(color.rgb, FogColor, EyeVectorModelSpaceFogPlaneVertexDist.xyz, EyeVectorModelSpaceFogPlaneVertexDist.w, FogRangeRecip, FogPlaneViewDist, FogHeightFade, Texture_FogMask, Texture_FogHeightTexture);\n"
3279 "#endif\n"
3280 "\n"
3281 "       // reflection must come last because it already contains exactly the correct fog (the reflection render preserves camera distance from the plane, it only flips the side) and ContrastBoost/SceneBrightness\n"
3282 "#ifdef USEREFLECTION\n"
3283 "       float4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
3284 "       //float4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(half3(tex2D(Texture_Normal, TexCoord)) - half3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
3285 "       float2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW.zw + ScreenCenterRefractReflect.zw;\n"
3286 "       float2 ScreenTexCoord = SafeScreenTexCoord + float3(normalize(half3(tex2D(Texture_Normal, TexCoord)) - half3(0.5))).xy * DistortScaleRefractReflect.zw;\n"
3287 "       // FIXME temporary hack to detect the case that the reflection\n"
3288 "       // gets blackened at edges due to leaving the area that contains actual\n"
3289 "       // content.\n"
3290 "       // Remove this 'ack once we have a better way to stop this thing from\n"
3291 "       // 'appening.\n"
3292 "       float f = min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(0.01, 0.01)).rgb) / 0.05);\n"
3293 "       f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(0.01, -0.01)).rgb) / 0.05);\n"
3294 "       f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(-0.01, 0.01)).rgb) / 0.05);\n"
3295 "       f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(-0.01, -0.01)).rgb) / 0.05);\n"
3296 "       ScreenTexCoord = lerp(SafeScreenTexCoord, ScreenTexCoord, f);\n"
3297 "       color.rgb = lerp(color.rgb, half3(tex2D(Texture_Reflection, ScreenTexCoord)) * ReflectColor.rgb, ReflectColor.a);\n"
3298 "#endif\n"
3299 "\n"
3300 "       gl_FragColor = float4(color);\n"
3301 "}\n"
3302 "#endif // FRAGMENT_SHADER\n"
3303 "\n"
3304 "#endif // !MODE_DEFERREDLIGHTSOURCE\n"
3305 "#endif // !MODE_DEFERREDGEOMETRY\n"
3306 "#endif // !MODE_WATER\n"
3307 "#endif // !MODE_REFRACTION\n"
3308 "#endif // !MODE_BLOOMBLUR\n"
3309 "#endif // !MODE_GENERIC\n"
3310 "#endif // !MODE_POSTPROCESS\n"
3311 "#endif // !MODE_SHOWDEPTH\n"
3312 "#endif // !MODE_DEPTH_OR_SHADOW\n"
3313 ;
3314
3315 char *glslshaderstring = NULL;
3316 char *cgshaderstring = NULL;
3317
3318 //=======================================================================================================================================================
3319
3320 typedef struct shaderpermutationinfo_s
3321 {
3322         const char *pretext;
3323         const char *name;
3324 }
3325 shaderpermutationinfo_t;
3326
3327 typedef struct shadermodeinfo_s
3328 {
3329         const char *vertexfilename;
3330         const char *geometryfilename;
3331         const char *fragmentfilename;
3332         const char *pretext;
3333         const char *name;
3334 }
3335 shadermodeinfo_t;
3336
3337 typedef enum shaderpermutation_e
3338 {
3339         SHADERPERMUTATION_DIFFUSE = 1<<0, ///< (lightsource) whether to use directional shading
3340         SHADERPERMUTATION_VERTEXTEXTUREBLEND = 1<<1, ///< indicates this is a two-layer material blend based on vertex alpha (q3bsp)
3341         SHADERPERMUTATION_VIEWTINT = 1<<2, ///< view tint (postprocessing only)
3342         SHADERPERMUTATION_COLORMAPPING = 1<<3, ///< indicates this is a colormapped skin
3343         SHADERPERMUTATION_SATURATION = 1<<4, ///< saturation (postprocessing only)
3344         SHADERPERMUTATION_FOGINSIDE = 1<<5, ///< tint the color by fog color or black if using additive blend mode
3345         SHADERPERMUTATION_FOGOUTSIDE = 1<<6, ///< tint the color by fog color or black if using additive blend mode
3346         SHADERPERMUTATION_FOGHEIGHTTEXTURE = 1<<7, ///< fog color and density determined by texture mapped on vertical axis
3347         SHADERPERMUTATION_GAMMARAMPS = 1<<8, ///< gamma (postprocessing only)
3348         SHADERPERMUTATION_CUBEFILTER = 1<<9, ///< (lightsource) use cubemap light filter
3349         SHADERPERMUTATION_GLOW = 1<<10, ///< (lightmap) blend in an additive glow texture
3350         SHADERPERMUTATION_BLOOM = 1<<11, ///< bloom (postprocessing only)
3351         SHADERPERMUTATION_SPECULAR = 1<<12, ///< (lightsource or deluxemapping) render specular effects
3352         SHADERPERMUTATION_POSTPROCESSING = 1<<13, ///< user defined postprocessing (postprocessing only)
3353         SHADERPERMUTATION_EXACTSPECULARMATH = 1<<14, ///< (lightsource or deluxemapping) use exact reflection map for specular effects, as opposed to the usual OpenGL approximation
3354         SHADERPERMUTATION_REFLECTION = 1<<15, ///< normalmap-perturbed reflection of the scene infront of the surface, preformed as an overlay on the surface
3355         SHADERPERMUTATION_OFFSETMAPPING = 1<<16, ///< adjust texcoords to roughly simulate a displacement mapped surface
3356         SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING = 1<<17, ///< adjust texcoords to accurately simulate a displacement mapped surface (requires OFFSETMAPPING to also be set!)
3357         SHADERPERMUTATION_SHADOWMAPRECT = 1<<18, ///< (lightsource) use shadowmap rectangle texture as light filter
3358         SHADERPERMUTATION_SHADOWMAPCUBE = 1<<19, ///< (lightsource) use shadowmap cubemap texture as light filter
3359         SHADERPERMUTATION_SHADOWMAP2D = 1<<20, ///< (lightsource) use shadowmap rectangle texture as light filter
3360         SHADERPERMUTATION_SHADOWMAPPCF = 1<<21, ///< (lightsource) use percentage closer filtering on shadowmap test results
3361         SHADERPERMUTATION_SHADOWMAPPCF2 = 1<<22, ///< (lightsource) use higher quality percentage closer filtering on shadowmap test results
3362         SHADERPERMUTATION_SHADOWSAMPLER = 1<<23, ///< (lightsource) use hardware shadowmap test
3363         SHADERPERMUTATION_SHADOWMAPVSDCT = 1<<24, ///< (lightsource) use virtual shadow depth cube texture for shadowmap indexing
3364         SHADERPERMUTATION_SHADOWMAPORTHO = 1<<25, //< (lightsource) use orthographic shadowmap projection
3365         SHADERPERMUTATION_DEFERREDLIGHTMAP = 1<<26, ///< (lightmap) read Texture_ScreenDiffuse/Specular textures and add them on top of lightmapping
3366         SHADERPERMUTATION_ALPHAKILL = 1<<27, ///< (deferredgeometry) discard pixel if diffuse texture alpha below 0.5
3367         SHADERPERMUTATION_REFLECTCUBE = 1<<28, ///< fake reflections using global cubemap (not HDRI light probe)
3368         SHADERPERMUTATION_LIMIT = 1<<29, ///< size of permutations array
3369         SHADERPERMUTATION_COUNT = 29 ///< size of shaderpermutationinfo array
3370 }
3371 shaderpermutation_t;
3372
3373 // NOTE: MUST MATCH ORDER OF SHADERPERMUTATION_* DEFINES!
3374 shaderpermutationinfo_t shaderpermutationinfo[SHADERPERMUTATION_COUNT] =
3375 {
3376         {"#define USEDIFFUSE\n", " diffuse"},
3377         {"#define USEVERTEXTEXTUREBLEND\n", " vertextextureblend"},
3378         {"#define USEVIEWTINT\n", " viewtint"},
3379         {"#define USECOLORMAPPING\n", " colormapping"},
3380         {"#define USESATURATION\n", " saturation"},
3381         {"#define USEFOGINSIDE\n", " foginside"},
3382         {"#define USEFOGOUTSIDE\n", " fogoutside"},
3383         {"#define USEFOGHEIGHTTEXTURE\n", " fogheighttexture"},
3384         {"#define USEGAMMARAMPS\n", " gammaramps"},
3385         {"#define USECUBEFILTER\n", " cubefilter"},
3386         {"#define USEGLOW\n", " glow"},
3387         {"#define USEBLOOM\n", " bloom"},
3388         {"#define USESPECULAR\n", " specular"},
3389         {"#define USEPOSTPROCESSING\n", " postprocessing"},
3390         {"#define USEEXACTSPECULARMATH\n", " exactspecularmath"},
3391         {"#define USEREFLECTION\n", " reflection"},
3392         {"#define USEOFFSETMAPPING\n", " offsetmapping"},
3393         {"#define USEOFFSETMAPPING_RELIEFMAPPING\n", " reliefmapping"},
3394         {"#define USESHADOWMAPRECT\n", " shadowmaprect"},
3395         {"#define USESHADOWMAPCUBE\n", " shadowmapcube"},
3396         {"#define USESHADOWMAP2D\n", " shadowmap2d"},
3397         {"#define USESHADOWMAPPCF 1\n", " shadowmappcf"},
3398         {"#define USESHADOWMAPPCF 2\n", " shadowmappcf2"},
3399         {"#define USESHADOWSAMPLER\n", " shadowsampler"},
3400         {"#define USESHADOWMAPVSDCT\n", " shadowmapvsdct"},
3401         {"#define USESHADOWMAPORTHO\n", " shadowmaportho"},
3402         {"#define USEDEFERREDLIGHTMAP\n", " deferredlightmap"},
3403         {"#define USEALPHAKILL\n", " alphakill"},
3404         {"#define USEREFLECTCUBE\n", " reflectcube"},
3405 };
3406
3407 /// this enum is multiplied by SHADERPERMUTATION_MODEBASE
3408 typedef enum shadermode_e
3409 {
3410         SHADERMODE_GENERIC, ///< (particles/HUD/etc) vertex color, optionally multiplied by one texture
3411         SHADERMODE_POSTPROCESS, ///< postprocessing shader (r_glsl_postprocess)
3412         SHADERMODE_DEPTH_OR_SHADOW, ///< (depthfirst/shadows) vertex shader only
3413         SHADERMODE_FLATCOLOR, ///< (lightmap) modulate texture by uniform color (q1bsp, q3bsp)
3414         SHADERMODE_VERTEXCOLOR, ///< (lightmap) modulate texture by vertex colors (q3bsp)
3415         SHADERMODE_LIGHTMAP, ///< (lightmap) modulate texture by lightmap texture (q1bsp, q3bsp)
3416         SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE, ///< (lightmap) use directional pixel shading from texture containing modelspace light directions (q3bsp deluxemap)
3417         SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE, ///< (lightmap) use directional pixel shading from texture containing tangentspace light directions (q1bsp deluxemap)
3418         SHADERMODE_LIGHTDIRECTION, ///< (lightmap) use directional pixel shading from fixed light direction (q3bsp)
3419         SHADERMODE_LIGHTSOURCE, ///< (lightsource) use directional pixel shading from light source (rtlight)
3420         SHADERMODE_REFRACTION, ///< refract background (the material is rendered normally after this pass)
3421         SHADERMODE_WATER, ///< refract background and reflection (the material is rendered normally after this pass)
3422         SHADERMODE_SHOWDEPTH, ///< (debugging) renders depth as color
3423         SHADERMODE_DEFERREDGEOMETRY, ///< (deferred) render material properties to screenspace geometry buffers
3424         SHADERMODE_DEFERREDLIGHTSOURCE, ///< (deferred) use directional pixel shading from light source (rtlight) on screenspace geometry buffers
3425         SHADERMODE_COUNT
3426 }
3427 shadermode_t;
3428
3429 // NOTE: MUST MATCH ORDER OF SHADERMODE_* ENUMS!
3430 shadermodeinfo_t glslshadermodeinfo[SHADERMODE_COUNT] =
3431 {
3432         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_GENERIC\n", " generic"},
3433         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_POSTPROCESS\n", " postprocess"},
3434         {"glsl/default.glsl", NULL, NULL               , "#define MODE_DEPTH_OR_SHADOW\n", " depth/shadow"},
3435         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_FLATCOLOR\n", " flatcolor"},
3436         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_VERTEXCOLOR\n", " vertexcolor"},
3437         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTMAP\n", " lightmap"},
3438         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
3439         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
3440         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTION\n", " lightdirection"},
3441         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTSOURCE\n", " lightsource"},
3442         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_REFRACTION\n", " refraction"},
3443         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_WATER\n", " water"},
3444         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_SHOWDEPTH\n", " showdepth"},
3445         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_DEFERREDGEOMETRY\n", " deferredgeometry"},
3446         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_DEFERREDLIGHTSOURCE\n", " deferredlightsource"},
3447 };
3448
3449 #ifdef SUPPORTCG
3450 shadermodeinfo_t cgshadermodeinfo[SHADERMODE_COUNT] =
3451 {
3452         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_GENERIC\n", " generic"},
3453         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_POSTPROCESS\n", " postprocess"},
3454         {"cg/default.cg", NULL, NULL           , "#define MODE_DEPTH_OR_SHADOW\n", " depth"},
3455         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_FLATCOLOR\n", " flatcolor"},
3456         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_VERTEXCOLOR\n", " vertexcolor"},
3457         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTMAP\n", " lightmap"},
3458         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
3459         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
3460         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTDIRECTION\n", " lightdirection"},
3461         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTSOURCE\n", " lightsource"},
3462         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_REFRACTION\n", " refraction"},
3463         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_WATER\n", " water"},
3464         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_SHOWDEPTH\n", " showdepth"},
3465         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_DEFERREDGEOMETRY\n", " deferredgeometry"},
3466         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_DEFERREDLIGHTSOURCE\n", " deferredlightsource"},
3467 };
3468 #endif
3469
3470 struct r_glsl_permutation_s;
3471 typedef struct r_glsl_permutation_s
3472 {
3473         /// hash lookup data
3474         struct r_glsl_permutation_s *hashnext;
3475         unsigned int mode;
3476         unsigned int permutation;
3477
3478         /// indicates if we have tried compiling this permutation already
3479         qboolean compiled;
3480         /// 0 if compilation failed
3481         int program;
3482         /// locations of detected uniforms in program object, or -1 if not found
3483         int loc_Texture_First;
3484         int loc_Texture_Second;
3485         int loc_Texture_GammaRamps;
3486         int loc_Texture_Normal;
3487         int loc_Texture_Color;
3488         int loc_Texture_Gloss;
3489         int loc_Texture_Glow;
3490         int loc_Texture_SecondaryNormal;
3491         int loc_Texture_SecondaryColor;
3492         int loc_Texture_SecondaryGloss;
3493         int loc_Texture_SecondaryGlow;
3494         int loc_Texture_Pants;
3495         int loc_Texture_Shirt;
3496         int loc_Texture_FogHeightTexture;
3497         int loc_Texture_FogMask;
3498         int loc_Texture_Lightmap;
3499         int loc_Texture_Deluxemap;
3500         int loc_Texture_Attenuation;
3501         int loc_Texture_Cube;
3502         int loc_Texture_Refraction;
3503         int loc_Texture_Reflection;
3504         int loc_Texture_ShadowMapRect;
3505         int loc_Texture_ShadowMapCube;
3506         int loc_Texture_ShadowMap2D;
3507         int loc_Texture_CubeProjection;
3508         int loc_Texture_ScreenDepth;
3509         int loc_Texture_ScreenNormalMap;
3510         int loc_Texture_ScreenDiffuse;
3511         int loc_Texture_ScreenSpecular;
3512         int loc_Texture_ReflectMask;
3513         int loc_Texture_ReflectCube;
3514         int loc_Alpha;
3515         int loc_BloomBlur_Parameters;
3516         int loc_ClientTime;
3517         int loc_Color_Ambient;
3518         int loc_Color_Diffuse;
3519         int loc_Color_Specular;
3520         int loc_Color_Glow;
3521         int loc_Color_Pants;
3522         int loc_Color_Shirt;
3523         int loc_DeferredColor_Ambient;
3524         int loc_DeferredColor_Diffuse;
3525         int loc_DeferredColor_Specular;
3526         int loc_DeferredMod_Diffuse;
3527         int loc_DeferredMod_Specular;
3528         int loc_DistortScaleRefractReflect;
3529         int loc_EyePosition;
3530         int loc_FogColor;
3531         int loc_FogHeightFade;
3532         int loc_FogPlane;
3533         int loc_FogPlaneViewDist;
3534         int loc_FogRangeRecip;
3535         int loc_LightColor;
3536         int loc_LightDir;
3537         int loc_LightPosition;
3538         int loc_OffsetMapping_Scale;
3539         int loc_PixelSize;
3540         int loc_ReflectColor;
3541         int loc_ReflectFactor;
3542         int loc_ReflectOffset;
3543         int loc_RefractColor;
3544         int loc_Saturation;
3545         int loc_ScreenCenterRefractReflect;
3546         int loc_ScreenScaleRefractReflect;
3547         int loc_ScreenToDepth;
3548         int loc_ShadowMap_Parameters;
3549         int loc_ShadowMap_TextureScale;
3550         int loc_SpecularPower;
3551         int loc_UserVec1;
3552         int loc_UserVec2;
3553         int loc_UserVec3;
3554         int loc_UserVec4;
3555         int loc_ViewTintColor;
3556         int loc_ViewToLight;
3557         int loc_ModelToLight;
3558         int loc_TexMatrix;
3559         int loc_BackgroundTexMatrix;
3560         int loc_ModelViewProjectionMatrix;
3561         int loc_ModelViewMatrix;
3562         int loc_PixelToScreenTexCoord;
3563         int loc_ModelToReflectCube;
3564         int loc_ShadowMapMatrix;
3565 }
3566 r_glsl_permutation_t;
3567
3568 #define SHADERPERMUTATION_HASHSIZE 256
3569
3570 /// information about each possible shader permutation
3571 r_glsl_permutation_t *r_glsl_permutationhash[SHADERMODE_COUNT][SHADERPERMUTATION_HASHSIZE];
3572 /// currently selected permutation
3573 r_glsl_permutation_t *r_glsl_permutation;
3574 /// storage for permutations linked in the hash table
3575 memexpandablearray_t r_glsl_permutationarray;
3576
3577 static r_glsl_permutation_t *R_GLSL_FindPermutation(unsigned int mode, unsigned int permutation)
3578 {
3579         //unsigned int hashdepth = 0;
3580         unsigned int hashindex = (permutation * 0x1021) & (SHADERPERMUTATION_HASHSIZE - 1);
3581         r_glsl_permutation_t *p;
3582         for (p = r_glsl_permutationhash[mode][hashindex];p;p = p->hashnext)
3583         {
3584                 if (p->mode == mode && p->permutation == permutation)
3585                 {
3586                         //if (hashdepth > 10)
3587                         //      Con_Printf("R_GLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
3588                         return p;
3589                 }
3590                 //hashdepth++;
3591         }
3592         p = (r_glsl_permutation_t*)Mem_ExpandableArray_AllocRecord(&r_glsl_permutationarray);
3593         p->mode = mode;
3594         p->permutation = permutation;
3595         p->hashnext = r_glsl_permutationhash[mode][hashindex];
3596         r_glsl_permutationhash[mode][hashindex] = p;
3597         //if (hashdepth > 10)
3598         //      Con_Printf("R_GLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
3599         return p;
3600 }
3601
3602 static char *R_GLSL_GetText(const char *filename, qboolean printfromdisknotice)
3603 {
3604         char *shaderstring;
3605         if (!filename || !filename[0])
3606                 return NULL;
3607         if (!strcmp(filename, "glsl/default.glsl"))
3608         {
3609                 if (!glslshaderstring)
3610                 {
3611                         glslshaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
3612                         if (glslshaderstring)
3613                                 Con_DPrintf("Loading shaders from file %s...\n", filename);
3614                         else
3615                                 glslshaderstring = (char *)builtinshaderstring;
3616                 }
3617                 shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(glslshaderstring) + 1);
3618                 memcpy(shaderstring, glslshaderstring, strlen(glslshaderstring) + 1);
3619                 return shaderstring;
3620         }
3621         shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
3622         if (shaderstring)
3623         {
3624                 if (printfromdisknotice)
3625                         Con_DPrintf("from disk %s... ", filename);
3626                 return shaderstring;
3627         }
3628         return shaderstring;
3629 }
3630
3631 static void R_GLSL_CompilePermutation(r_glsl_permutation_t *p, unsigned int mode, unsigned int permutation)
3632 {
3633         int i;
3634         shadermodeinfo_t *modeinfo = glslshadermodeinfo + mode;
3635         int vertstrings_count = 0;
3636         int geomstrings_count = 0;
3637         int fragstrings_count = 0;
3638         char *vertexstring, *geometrystring, *fragmentstring;
3639         const char *vertstrings_list[32+3];
3640         const char *geomstrings_list[32+3];
3641         const char *fragstrings_list[32+3];
3642         char permutationname[256];
3643
3644         if (p->compiled)
3645                 return;
3646         p->compiled = true;
3647         p->program = 0;
3648
3649         permutationname[0] = 0;
3650         vertexstring   = R_GLSL_GetText(modeinfo->vertexfilename, true);
3651         geometrystring = R_GLSL_GetText(modeinfo->geometryfilename, false);
3652         fragmentstring = R_GLSL_GetText(modeinfo->fragmentfilename, false);
3653
3654         strlcat(permutationname, modeinfo->vertexfilename, sizeof(permutationname));
3655
3656         // the first pretext is which type of shader to compile as
3657         // (later these will all be bound together as a program object)
3658         vertstrings_list[vertstrings_count++] = "#define VERTEX_SHADER\n";
3659         geomstrings_list[geomstrings_count++] = "#define GEOMETRY_SHADER\n";
3660         fragstrings_list[fragstrings_count++] = "#define FRAGMENT_SHADER\n";
3661
3662         // the second pretext is the mode (for example a light source)
3663         vertstrings_list[vertstrings_count++] = modeinfo->pretext;
3664         geomstrings_list[geomstrings_count++] = modeinfo->pretext;
3665         fragstrings_list[fragstrings_count++] = modeinfo->pretext;
3666         strlcat(permutationname, modeinfo->name, sizeof(permutationname));
3667
3668         // now add all the permutation pretexts
3669         for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
3670         {
3671                 if (permutation & (1<<i))
3672                 {
3673                         vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i].pretext;
3674                         geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i].pretext;
3675                         fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i].pretext;
3676                         strlcat(permutationname, shaderpermutationinfo[i].name, sizeof(permutationname));
3677                 }
3678                 else
3679                 {
3680                         // keep line numbers correct
3681                         vertstrings_list[vertstrings_count++] = "\n";
3682                         geomstrings_list[geomstrings_count++] = "\n";
3683                         fragstrings_list[fragstrings_count++] = "\n";
3684                 }
3685         }
3686
3687         // now append the shader text itself
3688         vertstrings_list[vertstrings_count++] = vertexstring;
3689         geomstrings_list[geomstrings_count++] = geometrystring;
3690         fragstrings_list[fragstrings_count++] = fragmentstring;
3691
3692         // if any sources were NULL, clear the respective list
3693         if (!vertexstring)
3694                 vertstrings_count = 0;
3695         if (!geometrystring)
3696                 geomstrings_count = 0;
3697         if (!fragmentstring)
3698                 fragstrings_count = 0;
3699
3700         // compile the shader program
3701         if (vertstrings_count + geomstrings_count + fragstrings_count)
3702                 p->program = GL_Backend_CompileProgram(vertstrings_count, vertstrings_list, geomstrings_count, geomstrings_list, fragstrings_count, fragstrings_list);
3703         if (p->program)
3704         {
3705                 CHECKGLERROR
3706                 qglUseProgramObjectARB(p->program);CHECKGLERROR
3707                 // look up all the uniform variable names we care about, so we don't
3708                 // have to look them up every time we set them
3709
3710                 p->loc_Texture_First              = qglGetUniformLocationARB(p->program, "Texture_First");
3711                 p->loc_Texture_Second             = qglGetUniformLocationARB(p->program, "Texture_Second");
3712                 p->loc_Texture_GammaRamps         = qglGetUniformLocationARB(p->program, "Texture_GammaRamps");
3713                 p->loc_Texture_Normal             = qglGetUniformLocationARB(p->program, "Texture_Normal");
3714                 p->loc_Texture_Color              = qglGetUniformLocationARB(p->program, "Texture_Color");
3715                 p->loc_Texture_Gloss              = qglGetUniformLocationARB(p->program, "Texture_Gloss");
3716                 p->loc_Texture_Glow               = qglGetUniformLocationARB(p->program, "Texture_Glow");
3717                 p->loc_Texture_SecondaryNormal    = qglGetUniformLocationARB(p->program, "Texture_SecondaryNormal");
3718                 p->loc_Texture_SecondaryColor     = qglGetUniformLocationARB(p->program, "Texture_SecondaryColor");
3719                 p->loc_Texture_SecondaryGloss     = qglGetUniformLocationARB(p->program, "Texture_SecondaryGloss");
3720                 p->loc_Texture_SecondaryGlow      = qglGetUniformLocationARB(p->program, "Texture_SecondaryGlow");
3721                 p->loc_Texture_Pants              = qglGetUniformLocationARB(p->program, "Texture_Pants");
3722                 p->loc_Texture_Shirt              = qglGetUniformLocationARB(p->program, "Texture_Shirt");
3723                 p->loc_Texture_FogHeightTexture   = qglGetUniformLocationARB(p->program, "Texture_FogHeightTexture");
3724                 p->loc_Texture_FogMask            = qglGetUniformLocationARB(p->program, "Texture_FogMask");
3725                 p->loc_Texture_Lightmap           = qglGetUniformLocationARB(p->program, "Texture_Lightmap");
3726                 p->loc_Texture_Deluxemap          = qglGetUniformLocationARB(p->program, "Texture_Deluxemap");
3727                 p->loc_Texture_Attenuation        = qglGetUniformLocationARB(p->program, "Texture_Attenuation");
3728                 p->loc_Texture_Cube               = qglGetUniformLocationARB(p->program, "Texture_Cube");
3729                 p->loc_Texture_Refraction         = qglGetUniformLocationARB(p->program, "Texture_Refraction");
3730                 p->loc_Texture_Reflection         = qglGetUniformLocationARB(p->program, "Texture_Reflection");
3731                 p->loc_Texture_ShadowMapRect      = qglGetUniformLocationARB(p->program, "Texture_ShadowMapRect");
3732                 p->loc_Texture_ShadowMapCube      = qglGetUniformLocationARB(p->program, "Texture_ShadowMapCube");
3733                 p->loc_Texture_ShadowMap2D        = qglGetUniformLocationARB(p->program, "Texture_ShadowMap2D");
3734                 p->loc_Texture_CubeProjection     = qglGetUniformLocationARB(p->program, "Texture_CubeProjection");
3735                 p->loc_Texture_ScreenDepth        = qglGetUniformLocationARB(p->program, "Texture_ScreenDepth");
3736                 p->loc_Texture_ScreenNormalMap    = qglGetUniformLocationARB(p->program, "Texture_ScreenNormalMap");
3737                 p->loc_Texture_ScreenDiffuse      = qglGetUniformLocationARB(p->program, "Texture_ScreenDiffuse");
3738                 p->loc_Texture_ScreenSpecular     = qglGetUniformLocationARB(p->program, "Texture_ScreenSpecular");
3739                 p->loc_Texture_ReflectMask        = qglGetUniformLocationARB(p->program, "Texture_ReflectMask");
3740                 p->loc_Texture_ReflectCube        = qglGetUniformLocationARB(p->program, "Texture_ReflectCube");
3741                 p->loc_Alpha                      = qglGetUniformLocationARB(p->program, "Alpha");
3742                 p->loc_BloomBlur_Parameters       = qglGetUniformLocationARB(p->program, "BloomBlur_Parameters");
3743                 p->loc_ClientTime                 = qglGetUniformLocationARB(p->program, "ClientTime");
3744                 p->loc_Color_Ambient              = qglGetUniformLocationARB(p->program, "Color_Ambient");
3745                 p->loc_Color_Diffuse              = qglGetUniformLocationARB(p->program, "Color_Diffuse");
3746                 p->loc_Color_Specular             = qglGetUniformLocationARB(p->program, "Color_Specular");
3747                 p->loc_Color_Glow                 = qglGetUniformLocationARB(p->program, "Color_Glow");
3748                 p->loc_Color_Pants                = qglGetUniformLocationARB(p->program, "Color_Pants");
3749                 p->loc_Color_Shirt                = qglGetUniformLocationARB(p->program, "Color_Shirt");
3750                 p->loc_DeferredColor_Ambient      = qglGetUniformLocationARB(p->program, "DeferredColor_Ambient");
3751                 p->loc_DeferredColor_Diffuse      = qglGetUniformLocationARB(p->program, "DeferredColor_Diffuse");
3752                 p->loc_DeferredColor_Specular     = qglGetUniformLocationARB(p->program, "DeferredColor_Specular");
3753                 p->loc_DeferredMod_Diffuse        = qglGetUniformLocationARB(p->program, "DeferredMod_Diffuse");
3754                 p->loc_DeferredMod_Specular       = qglGetUniformLocationARB(p->program, "DeferredMod_Specular");
3755                 p->loc_DistortScaleRefractReflect = qglGetUniformLocationARB(p->program, "DistortScaleRefractReflect");
3756                 p->loc_EyePosition                = qglGetUniformLocationARB(p->program, "EyePosition");
3757                 p->loc_FogColor                   = qglGetUniformLocationARB(p->program, "FogColor");
3758                 p->loc_FogHeightFade              = qglGetUniformLocationARB(p->program, "FogHeightFade");
3759                 p->loc_FogPlane                   = qglGetUniformLocationARB(p->program, "FogPlane");
3760                 p->loc_FogPlaneViewDist           = qglGetUniformLocationARB(p->program, "FogPlaneViewDist");
3761                 p->loc_FogRangeRecip              = qglGetUniformLocationARB(p->program, "FogRangeRecip");
3762                 p->loc_LightColor                 = qglGetUniformLocationARB(p->program, "LightColor");
3763                 p->loc_LightDir                   = qglGetUniformLocationARB(p->program, "LightDir");
3764                 p->loc_LightPosition              = qglGetUniformLocationARB(p->program, "LightPosition");
3765                 p->loc_OffsetMapping_Scale        = qglGetUniformLocationARB(p->program, "OffsetMapping_Scale");
3766                 p->loc_PixelSize                  = qglGetUniformLocationARB(p->program, "PixelSize");
3767                 p->loc_ReflectColor               = qglGetUniformLocationARB(p->program, "ReflectColor");
3768                 p->loc_ReflectFactor              = qglGetUniformLocationARB(p->program, "ReflectFactor");
3769                 p->loc_ReflectOffset              = qglGetUniformLocationARB(p->program, "ReflectOffset");
3770                 p->loc_RefractColor               = qglGetUniformLocationARB(p->program, "RefractColor");
3771                 p->loc_Saturation                 = qglGetUniformLocationARB(p->program, "Saturation");
3772                 p->loc_ScreenCenterRefractReflect = qglGetUniformLocationARB(p->program, "ScreenCenterRefractReflect");
3773                 p->loc_ScreenScaleRefractReflect  = qglGetUniformLocationARB(p->program, "ScreenScaleRefractReflect");
3774                 p->loc_ScreenToDepth              = qglGetUniformLocationARB(p->program, "ScreenToDepth");
3775                 p->loc_ShadowMap_Parameters       = qglGetUniformLocationARB(p->program, "ShadowMap_Parameters");
3776                 p->loc_ShadowMap_TextureScale     = qglGetUniformLocationARB(p->program, "ShadowMap_TextureScale");
3777                 p->loc_SpecularPower              = qglGetUniformLocationARB(p->program, "SpecularPower");
3778                 p->loc_UserVec1                   = qglGetUniformLocationARB(p->program, "UserVec1");
3779                 p->loc_UserVec2                   = qglGetUniformLocationARB(p->program, "UserVec2");
3780                 p->loc_UserVec3                   = qglGetUniformLocationARB(p->program, "UserVec3");
3781                 p->loc_UserVec4                   = qglGetUniformLocationARB(p->program, "UserVec4");
3782                 p->loc_ViewTintColor              = qglGetUniformLocationARB(p->program, "ViewTintColor");
3783                 p->loc_ViewToLight                = qglGetUniformLocationARB(p->program, "ViewToLight");
3784                 p->loc_ModelToLight               = qglGetUniformLocationARB(p->program, "ModelToLight");
3785                 p->loc_TexMatrix                  = qglGetUniformLocationARB(p->program, "TexMatrix");
3786                 p->loc_BackgroundTexMatrix        = qglGetUniformLocationARB(p->program, "BackgroundTexMatrix");
3787                 p->loc_ModelViewMatrix            = qglGetUniformLocationARB(p->program, "ModelViewMatrix");
3788                 p->loc_ModelViewProjectionMatrix  = qglGetUniformLocationARB(p->program, "ModelViewProjectionMatrix");
3789                 p->loc_PixelToScreenTexCoord      = qglGetUniformLocationARB(p->program, "PixelToScreenTexCoord");
3790                 p->loc_ModelToReflectCube         = qglGetUniformLocationARB(p->program, "ModelToReflectCube");
3791                 p->loc_ShadowMapMatrix            = qglGetUniformLocationARB(p->program, "ShadowMapMatrix");
3792                 // initialize the samplers to refer to the texture units we use
3793                 if (p->loc_Texture_First           >= 0) qglUniform1iARB(p->loc_Texture_First          , GL20TU_FIRST);
3794                 if (p->loc_Texture_Second          >= 0) qglUniform1iARB(p->loc_Texture_Second         , GL20TU_SECOND);
3795                 if (p->loc_Texture_GammaRamps      >= 0) qglUniform1iARB(p->loc_Texture_GammaRamps     , GL20TU_GAMMARAMPS);
3796                 if (p->loc_Texture_Normal          >= 0) qglUniform1iARB(p->loc_Texture_Normal         , GL20TU_NORMAL);
3797                 if (p->loc_Texture_Color           >= 0) qglUniform1iARB(p->loc_Texture_Color          , GL20TU_COLOR);
3798                 if (p->loc_Texture_Gloss           >= 0) qglUniform1iARB(p->loc_Texture_Gloss          , GL20TU_GLOSS);
3799                 if (p->loc_Texture_Glow            >= 0) qglUniform1iARB(p->loc_Texture_Glow           , GL20TU_GLOW);
3800                 if (p->loc_Texture_SecondaryNormal >= 0) qglUniform1iARB(p->loc_Texture_SecondaryNormal, GL20TU_SECONDARY_NORMAL);
3801                 if (p->loc_Texture_SecondaryColor  >= 0) qglUniform1iARB(p->loc_Texture_SecondaryColor , GL20TU_SECONDARY_COLOR);
3802                 if (p->loc_Texture_SecondaryGloss  >= 0) qglUniform1iARB(p->loc_Texture_SecondaryGloss , GL20TU_SECONDARY_GLOSS);
3803                 if (p->loc_Texture_SecondaryGlow   >= 0) qglUniform1iARB(p->loc_Texture_SecondaryGlow  , GL20TU_SECONDARY_GLOW);
3804                 if (p->loc_Texture_Pants           >= 0) qglUniform1iARB(p->loc_Texture_Pants          , GL20TU_PANTS);
3805                 if (p->loc_Texture_Shirt           >= 0) qglUniform1iARB(p->loc_Texture_Shirt          , GL20TU_SHIRT);
3806                 if (p->loc_Texture_FogHeightTexture>= 0) qglUniform1iARB(p->loc_Texture_FogHeightTexture, GL20TU_FOGHEIGHTTEXTURE);
3807                 if (p->loc_Texture_FogMask         >= 0) qglUniform1iARB(p->loc_Texture_FogMask        , GL20TU_FOGMASK);
3808                 if (p->loc_Texture_Lightmap        >= 0) qglUniform1iARB(p->loc_Texture_Lightmap       , GL20TU_LIGHTMAP);
3809                 if (p->loc_Texture_Deluxemap       >= 0) qglUniform1iARB(p->loc_Texture_Deluxemap      , GL20TU_DELUXEMAP);
3810                 if (p->loc_Texture_Attenuation     >= 0) qglUniform1iARB(p->loc_Texture_Attenuation    , GL20TU_ATTENUATION);
3811                 if (p->loc_Texture_Cube            >= 0) qglUniform1iARB(p->loc_Texture_Cube           , GL20TU_CUBE);
3812                 if (p->loc_Texture_Refraction      >= 0) qglUniform1iARB(p->loc_Texture_Refraction     , GL20TU_REFRACTION);
3813                 if (p->loc_Texture_Reflection      >= 0) qglUniform1iARB(p->loc_Texture_Reflection     , GL20TU_REFLECTION);
3814                 if (p->loc_Texture_ShadowMapRect   >= 0) qglUniform1iARB(p->loc_Texture_ShadowMapRect  , permutation & SHADERPERMUTATION_SHADOWMAPORTHO ? GL20TU_SHADOWMAPORTHORECT : GL20TU_SHADOWMAPRECT);
3815                 if (p->loc_Texture_ShadowMapCube   >= 0) qglUniform1iARB(p->loc_Texture_ShadowMapCube  , GL20TU_SHADOWMAPCUBE);
3816                 if (p->loc_Texture_ShadowMap2D     >= 0) qglUniform1iARB(p->loc_Texture_ShadowMap2D    , permutation & SHADERPERMUTATION_SHADOWMAPORTHO ? GL20TU_SHADOWMAPORTHO2D : GL20TU_SHADOWMAP2D);
3817                 if (p->loc_Texture_CubeProjection  >= 0) qglUniform1iARB(p->loc_Texture_CubeProjection , GL20TU_CUBEPROJECTION);
3818                 if (p->loc_Texture_ScreenDepth     >= 0) qglUniform1iARB(p->loc_Texture_ScreenDepth    , GL20TU_SCREENDEPTH);
3819                 if (p->loc_Texture_ScreenNormalMap >= 0) qglUniform1iARB(p->loc_Texture_ScreenNormalMap, GL20TU_SCREENNORMALMAP);
3820                 if (p->loc_Texture_ScreenDiffuse   >= 0) qglUniform1iARB(p->loc_Texture_ScreenDiffuse  , GL20TU_SCREENDIFFUSE);
3821                 if (p->loc_Texture_ScreenSpecular  >= 0) qglUniform1iARB(p->loc_Texture_ScreenSpecular , GL20TU_SCREENSPECULAR);
3822                 if (p->loc_Texture_ReflectMask     >= 0) qglUniform1iARB(p->loc_Texture_ReflectMask    , GL20TU_REFLECTMASK);
3823                 if (p->loc_Texture_ReflectCube     >= 0) qglUniform1iARB(p->loc_Texture_ReflectCube    , GL20TU_REFLECTCUBE);
3824                 CHECKGLERROR
3825                 Con_DPrintf("^5GLSL shader %s compiled.\n", permutationname);
3826         }
3827         else
3828                 Con_Printf("^1GLSL shader %s failed!  some features may not work properly.\n", permutationname);
3829
3830         // free the strings
3831         if (vertexstring)
3832                 Mem_Free(vertexstring);
3833         if (geometrystring)
3834                 Mem_Free(geometrystring);
3835         if (fragmentstring)
3836                 Mem_Free(fragmentstring);
3837 }
3838
3839 void R_SetupShader_SetPermutationGLSL(unsigned int mode, unsigned int permutation)
3840 {
3841         r_glsl_permutation_t *perm = R_GLSL_FindPermutation(mode, permutation);
3842         if (r_glsl_permutation != perm)
3843         {
3844                 r_glsl_permutation = perm;
3845                 if (!r_glsl_permutation->program)
3846                 {
3847                         if (!r_glsl_permutation->compiled)
3848                                 R_GLSL_CompilePermutation(perm, mode, permutation);
3849                         if (!r_glsl_permutation->program)
3850                         {
3851                                 // remove features until we find a valid permutation
3852                                 int i;
3853                                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
3854                                 {
3855                                         // reduce i more quickly whenever it would not remove any bits
3856                                         int j = 1<<(SHADERPERMUTATION_COUNT-1-i);
3857                                         if (!(permutation & j))
3858                                                 continue;
3859                                         permutation -= j;
3860                                         r_glsl_permutation = R_GLSL_FindPermutation(mode, permutation);
3861                                         if (!r_glsl_permutation->compiled)
3862                                                 R_GLSL_CompilePermutation(perm, mode, permutation);
3863                                         if (r_glsl_permutation->program)
3864                                                 break;
3865                                 }
3866                                 if (i >= SHADERPERMUTATION_COUNT)
3867                                 {
3868                                         //Con_Printf("Could not find a working OpenGL 2.0 shader for permutation %s %s\n", shadermodeinfo[mode].vertexfilename, shadermodeinfo[mode].pretext);
3869                                         r_glsl_permutation = R_GLSL_FindPermutation(mode, permutation);
3870                                         qglUseProgramObjectARB(0);CHECKGLERROR
3871                                         return; // no bit left to clear, entire mode is broken
3872                                 }
3873                         }
3874                 }
3875                 CHECKGLERROR
3876                 qglUseProgramObjectARB(r_glsl_permutation->program);CHECKGLERROR
3877         }
3878         if (r_glsl_permutation->loc_ModelViewProjectionMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewProjectionMatrix, 1, false, gl_modelviewprojection16f);
3879         if (r_glsl_permutation->loc_ModelViewMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewMatrix, 1, false, gl_modelview16f);
3880         if (r_glsl_permutation->loc_ClientTime >= 0) qglUniform1fARB(r_glsl_permutation->loc_ClientTime, cl.time);
3881 }
3882
3883 #ifdef SUPPORTCG
3884 #include <Cg/cgGL.h>
3885 struct r_cg_permutation_s;
3886 typedef struct r_cg_permutation_s
3887 {
3888         /// hash lookup data
3889         struct r_cg_permutation_s *hashnext;
3890         unsigned int mode;
3891         unsigned int permutation;
3892
3893         /// indicates if we have tried compiling this permutation already
3894         qboolean compiled;
3895         /// 0 if compilation failed
3896         CGprogram vprogram;
3897         CGprogram fprogram;
3898         /// locations of detected parameters in programs, or NULL if not found
3899         CGparameter vp_EyePosition;
3900         CGparameter vp_FogPlane;
3901         CGparameter vp_LightDir;
3902         CGparameter vp_LightPosition;
3903         CGparameter vp_ModelToLight;
3904         CGparameter vp_TexMatrix;
3905         CGparameter vp_BackgroundTexMatrix;
3906         CGparameter vp_ModelViewProjectionMatrix;
3907         CGparameter vp_ModelViewMatrix;
3908         CGparameter vp_ShadowMapMatrix;
3909
3910         CGparameter fp_Texture_First;
3911         CGparameter fp_Texture_Second;
3912         CGparameter fp_Texture_GammaRamps;
3913         CGparameter fp_Texture_Normal;
3914         CGparameter fp_Texture_Color;
3915         CGparameter fp_Texture_Gloss;
3916         CGparameter fp_Texture_Glow;
3917         CGparameter fp_Texture_SecondaryNormal;
3918         CGparameter fp_Texture_SecondaryColor;
3919         CGparameter fp_Texture_SecondaryGloss;
3920         CGparameter fp_Texture_SecondaryGlow;
3921         CGparameter fp_Texture_Pants;
3922         CGparameter fp_Texture_Shirt;
3923         CGparameter fp_Texture_FogHeightTexture;
3924         CGparameter fp_Texture_FogMask;
3925         CGparameter fp_Texture_Lightmap;
3926         CGparameter fp_Texture_Deluxemap;
3927         CGparameter fp_Texture_Attenuation;
3928         CGparameter fp_Texture_Cube;
3929         CGparameter fp_Texture_Refraction;
3930         CGparameter fp_Texture_Reflection;
3931         CGparameter fp_Texture_ShadowMapRect;
3932         CGparameter fp_Texture_ShadowMapCube;
3933         CGparameter fp_Texture_ShadowMap2D;
3934         CGparameter fp_Texture_CubeProjection;
3935         CGparameter fp_Texture_ScreenDepth;
3936         CGparameter fp_Texture_ScreenNormalMap;
3937         CGparameter fp_Texture_ScreenDiffuse;
3938         CGparameter fp_Texture_ScreenSpecular;
3939         CGparameter fp_Texture_ReflectMask;
3940         CGparameter fp_Texture_ReflectCube;
3941         CGparameter fp_Alpha;
3942         CGparameter fp_BloomBlur_Parameters;
3943         CGparameter fp_ClientTime;
3944         CGparameter fp_Color_Ambient;
3945         CGparameter fp_Color_Diffuse;
3946         CGparameter fp_Color_Specular;
3947         CGparameter fp_Color_Glow;
3948         CGparameter fp_Color_Pants;
3949         CGparameter fp_Color_Shirt;
3950         CGparameter fp_DeferredColor_Ambient;
3951         CGparameter fp_DeferredColor_Diffuse;
3952         CGparameter fp_DeferredColor_Specular;
3953         CGparameter fp_DeferredMod_Diffuse;
3954         CGparameter fp_DeferredMod_Specular;
3955         CGparameter fp_DistortScaleRefractReflect;
3956         CGparameter fp_EyePosition;
3957         CGparameter fp_FogColor;
3958         CGparameter fp_FogHeightFade;
3959         CGparameter fp_FogPlane;
3960         CGparameter fp_FogPlaneViewDist;
3961         CGparameter fp_FogRangeRecip;
3962         CGparameter fp_LightColor;
3963         CGparameter fp_LightDir;
3964         CGparameter fp_LightPosition;
3965         CGparameter fp_OffsetMapping_Scale;
3966         CGparameter fp_PixelSize;
3967         CGparameter fp_ReflectColor;
3968         CGparameter fp_ReflectFactor;
3969         CGparameter fp_ReflectOffset;
3970         CGparameter fp_RefractColor;
3971         CGparameter fp_Saturation;
3972         CGparameter fp_ScreenCenterRefractReflect;
3973         CGparameter fp_ScreenScaleRefractReflect;
3974         CGparameter fp_ScreenToDepth;
3975         CGparameter fp_ShadowMap_Parameters;
3976         CGparameter fp_ShadowMap_TextureScale;
3977         CGparameter fp_SpecularPower;
3978         CGparameter fp_UserVec1;
3979         CGparameter fp_UserVec2;
3980         CGparameter fp_UserVec3;
3981         CGparameter fp_UserVec4;
3982         CGparameter fp_ViewTintColor;
3983         CGparameter fp_ViewToLight;
3984         CGparameter fp_PixelToScreenTexCoord;
3985         CGparameter fp_ModelToReflectCube;
3986 }
3987 r_cg_permutation_t;
3988
3989 /// information about each possible shader permutation
3990 r_cg_permutation_t *r_cg_permutationhash[SHADERMODE_COUNT][SHADERPERMUTATION_HASHSIZE];
3991 /// currently selected permutation
3992 r_cg_permutation_t *r_cg_permutation;
3993 /// storage for permutations linked in the hash table
3994 memexpandablearray_t r_cg_permutationarray;
3995
3996 #define CHECKCGERROR {CGerror err = cgGetError(), err2 = err;if (err){Con_Printf("%s:%i CG error %i: %s : %s\n", __FILE__, __LINE__, err, cgGetErrorString(err), cgGetLastErrorString(&err2));if (err == 1) Con_Printf("last listing:\n%s\n", cgGetLastListing(vid.cgcontext));}}
3997
3998 static r_cg_permutation_t *R_CG_FindPermutation(unsigned int mode, unsigned int permutation)
3999 {
4000         //unsigned int hashdepth = 0;
4001         unsigned int hashindex = (permutation * 0x1021) & (SHADERPERMUTATION_HASHSIZE - 1);
4002         r_cg_permutation_t *p;
4003         for (p = r_cg_permutationhash[mode][hashindex];p;p = p->hashnext)
4004         {
4005                 if (p->mode == mode && p->permutation == permutation)
4006                 {
4007                         //if (hashdepth > 10)
4008                         //      Con_Printf("R_CG_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
4009                         return p;
4010                 }
4011                 //hashdepth++;
4012         }
4013         p = (r_cg_permutation_t*)Mem_ExpandableArray_AllocRecord(&r_cg_permutationarray);
4014         p->mode = mode;
4015         p->permutation = permutation;
4016         p->hashnext = r_cg_permutationhash[mode][hashindex];
4017         r_cg_permutationhash[mode][hashindex] = p;
4018         //if (hashdepth > 10)
4019         //      Con_Printf("R_CG_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
4020         return p;
4021 }
4022
4023 static char *R_CG_GetText(const char *filename, qboolean printfromdisknotice)
4024 {
4025         char *shaderstring;
4026         if (!filename || !filename[0])
4027                 return NULL;
4028         if (!strcmp(filename, "cg/default.cg"))
4029         {
4030                 if (!cgshaderstring)
4031                 {
4032                         cgshaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
4033                         if (cgshaderstring)
4034                                 Con_DPrintf("Loading shaders from file %s...\n", filename);
4035                         else
4036                                 cgshaderstring = (char *)builtincgshaderstring;
4037                 }
4038                 shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(cgshaderstring) + 1);
4039                 memcpy(shaderstring, cgshaderstring, strlen(cgshaderstring) + 1);
4040                 return shaderstring;
4041         }
4042         shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
4043         if (shaderstring)
4044         {
4045                 if (printfromdisknotice)
4046                         Con_DPrintf("from disk %s... ", filename);
4047                 return shaderstring;
4048         }
4049         return shaderstring;
4050 }
4051
4052 static void R_CG_CacheShader(r_cg_permutation_t *p, const char *cachename, const char *vertstring, const char *fragstring)
4053 {
4054         // TODO: load or create .fp and .vp shader files
4055 }
4056
4057 static void R_CG_CompilePermutation(r_cg_permutation_t *p, unsigned int mode, unsigned int permutation)
4058 {
4059         int i;
4060         shadermodeinfo_t *modeinfo = cgshadermodeinfo + mode;
4061         int vertstrings_count = 0, vertstring_length = 0;
4062         int geomstrings_count = 0, geomstring_length = 0;
4063         int fragstrings_count = 0, fragstring_length = 0;
4064         char *t;
4065         char *vertexstring, *geometrystring, *fragmentstring;
4066         char *vertstring, *geomstring, *fragstring;
4067         const char *vertstrings_list[32+3];
4068         const char *geomstrings_list[32+3];
4069         const char *fragstrings_list[32+3];
4070         char permutationname[256];
4071         char cachename[256];
4072         CGprofile vertexProfile;
4073         CGprofile fragmentProfile;
4074
4075         if (p->compiled)
4076                 return;
4077         p->compiled = true;
4078         p->vprogram = NULL;
4079         p->fprogram = NULL;
4080
4081         permutationname[0] = 0;
4082         cachename[0] = 0;
4083         vertexstring   = R_CG_GetText(modeinfo->vertexfilename, true);
4084         geometrystring = R_CG_GetText(modeinfo->geometryfilename, false);
4085         fragmentstring = R_CG_GetText(modeinfo->fragmentfilename, false);
4086
4087         strlcat(permutationname, modeinfo->vertexfilename, sizeof(permutationname));
4088         strlcat(cachename, "cg/", sizeof(cachename));
4089
4090         // the first pretext is which type of shader to compile as
4091         // (later these will all be bound together as a program object)
4092         vertstrings_list[vertstrings_count++] = "#define VERTEX_SHADER\n";
4093         geomstrings_list[geomstrings_count++] = "#define GEOMETRY_SHADER\n";
4094         fragstrings_list[fragstrings_count++] = "#define FRAGMENT_SHADER\n";
4095
4096         // the second pretext is the mode (for example a light source)
4097         vertstrings_list[vertstrings_count++] = modeinfo->pretext;
4098         geomstrings_list[geomstrings_count++] = modeinfo->pretext;
4099         fragstrings_list[fragstrings_count++] = modeinfo->pretext;
4100         strlcat(permutationname, modeinfo->name, sizeof(permutationname));
4101         strlcat(cachename, modeinfo->name, sizeof(cachename));
4102
4103         // now add all the permutation pretexts
4104         for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
4105         {
4106                 if (permutation & (1<<i))
4107                 {
4108                         vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i].pretext;
4109                         geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i].pretext;
4110                         fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i].pretext;
4111                         strlcat(permutationname, shaderpermutationinfo[i].name, sizeof(permutationname));
4112                         strlcat(cachename, shaderpermutationinfo[i].name, sizeof(cachename));
4113                 }
4114                 else
4115                 {
4116                         // keep line numbers correct
4117                         vertstrings_list[vertstrings_count++] = "\n";
4118                         geomstrings_list[geomstrings_count++] = "\n";
4119                         fragstrings_list[fragstrings_count++] = "\n";
4120                 }
4121         }
4122
4123         // replace spaces in the cachename with _ characters
4124         for (i = 0;cachename[i];i++)
4125                 if (cachename[i] == ' ')
4126                         cachename[i] = '_';
4127
4128         // now append the shader text itself
4129         vertstrings_list[vertstrings_count++] = vertexstring;
4130         geomstrings_list[geomstrings_count++] = geometrystring;
4131         fragstrings_list[fragstrings_count++] = fragmentstring;
4132
4133         // if any sources were NULL, clear the respective list
4134         if (!vertexstring)
4135                 vertstrings_count = 0;
4136         if (!geometrystring)
4137                 geomstrings_count = 0;
4138         if (!fragmentstring)
4139                 fragstrings_count = 0;
4140
4141         vertstring_length = 0;
4142         for (i = 0;i < vertstrings_count;i++)
4143                 vertstring_length += strlen(vertstrings_list[i]);
4144         vertstring = t = Mem_Alloc(tempmempool, vertstring_length + 1);
4145         for (i = 0;i < vertstrings_count;t += strlen(vertstrings_list[i]), i++)
4146                 memcpy(t, vertstrings_list[i], strlen(vertstrings_list[i]));
4147
4148         geomstring_length = 0;
4149         for (i = 0;i < geomstrings_count;i++)
4150                 geomstring_length += strlen(geomstrings_list[i]);
4151         geomstring = t = Mem_Alloc(tempmempool, geomstring_length + 1);
4152         for (i = 0;i < geomstrings_count;t += strlen(geomstrings_list[i]), i++)
4153                 memcpy(t, geomstrings_list[i], strlen(geomstrings_list[i]));
4154
4155         fragstring_length = 0;
4156         for (i = 0;i < fragstrings_count;i++)
4157                 fragstring_length += strlen(fragstrings_list[i]);
4158         fragstring = t = Mem_Alloc(tempmempool, fragstring_length + 1);
4159         for (i = 0;i < fragstrings_count;t += strlen(fragstrings_list[i]), i++)
4160                 memcpy(t, fragstrings_list[i], strlen(fragstrings_list[i]));
4161
4162         CHECKGLERROR
4163         CHECKCGERROR
4164         //vertexProfile = CG_PROFILE_ARBVP1;
4165         //fragmentProfile = CG_PROFILE_ARBFP1;
4166         vertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX);CHECKCGERROR
4167         fragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);CHECKCGERROR
4168         //cgGLSetOptimalOptions(vertexProfile);CHECKCGERROR
4169         //cgGLSetOptimalOptions(fragmentProfile);CHECKCGERROR
4170         //cgSetAutoCompile(vid.cgcontext, CG_COMPILE_MANUAL);CHECKCGERROR
4171         CHECKGLERROR
4172
4173         // try to load the cached shader, or generate one
4174         R_CG_CacheShader(p, cachename, vertstring, fragstring);
4175
4176         // if caching failed, do a dynamic compile for now
4177         CHECKCGERROR
4178         if (vertstring[0] && !p->vprogram)
4179                 p->vprogram = cgCreateProgram(vid.cgcontext, CG_SOURCE, vertstring, vertexProfile, NULL, NULL);
4180         CHECKCGERROR
4181         if (fragstring[0] && !p->fprogram)
4182                 p->fprogram = cgCreateProgram(vid.cgcontext, CG_SOURCE, fragstring, fragmentProfile, NULL, NULL);
4183         CHECKCGERROR
4184
4185         // look up all the uniform variable names we care about, so we don't
4186         // have to look them up every time we set them
4187         if (p->vprogram)
4188         {
4189                 CHECKCGERROR
4190                 cgGLLoadProgram(p->vprogram);CHECKCGERROR CHECKGLERROR
4191                 cgGLEnableProfile(vertexProfile);CHECKCGERROR CHECKGLERROR
4192                 p->vp_EyePosition                = cgGetNamedParameter(p->vprogram, "EyePosition");
4193                 p->vp_FogPlane                   = cgGetNamedParameter(p->vprogram, "FogPlane");
4194                 p->vp_LightDir                   = cgGetNamedParameter(p->vprogram, "LightDir");
4195                 p->vp_LightPosition              = cgGetNamedParameter(p->vprogram, "LightPosition");
4196                 p->vp_ModelToLight               = cgGetNamedParameter(p->vprogram, "ModelToLight");
4197                 p->vp_TexMatrix                  = cgGetNamedParameter(p->vprogram, "TexMatrix");
4198                 p->vp_BackgroundTexMatrix        = cgGetNamedParameter(p->vprogram, "BackgroundTexMatrix");
4199                 p->vp_ModelViewProjectionMatrix  = cgGetNamedParameter(p->vprogram, "ModelViewProjectionMatrix");
4200                 p->vp_ModelViewMatrix            = cgGetNamedParameter(p->vprogram, "ModelViewMatrix");
4201                 p->vp_ShadowMapMatrix            = cgGetNamedParameter(p->vprogram, "ShadowMapMatrix");
4202                 CHECKCGERROR
4203         }
4204         if (p->fprogram)
4205         {
4206                 CHECKCGERROR
4207                 cgGLLoadProgram(p->fprogram);CHECKCGERROR CHECKGLERROR
4208                 cgGLEnableProfile(fragmentProfile);CHECKCGERROR CHECKGLERROR
4209                 p->fp_Texture_First              = cgGetNamedParameter(p->fprogram, "Texture_First");
4210                 p->fp_Texture_Second             = cgGetNamedParameter(p->fprogram, "Texture_Second");
4211                 p->fp_Texture_GammaRamps         = cgGetNamedParameter(p->fprogram, "Texture_GammaRamps");
4212                 p->fp_Texture_Normal             = cgGetNamedParameter(p->fprogram, "Texture_Normal");
4213                 p->fp_Texture_Color              = cgGetNamedParameter(p->fprogram, "Texture_Color");
4214                 p->fp_Texture_Gloss              = cgGetNamedParameter(p->fprogram, "Texture_Gloss");
4215                 p->fp_Texture_Glow               = cgGetNamedParameter(p->fprogram, "Texture_Glow");
4216                 p->fp_Texture_SecondaryNormal    = cgGetNamedParameter(p->fprogram, "Texture_SecondaryNormal");
4217                 p->fp_Texture_SecondaryColor     = cgGetNamedParameter(p->fprogram, "Texture_SecondaryColor");
4218                 p->fp_Texture_SecondaryGloss     = cgGetNamedParameter(p->fprogram, "Texture_SecondaryGloss");
4219                 p->fp_Texture_SecondaryGlow      = cgGetNamedParameter(p->fprogram, "Texture_SecondaryGlow");
4220                 p->fp_Texture_Pants              = cgGetNamedParameter(p->fprogram, "Texture_Pants");
4221                 p->fp_Texture_Shirt              = cgGetNamedParameter(p->fprogram, "Texture_Shirt");
4222                 p->fp_Texture_FogHeightTexture   = cgGetNamedParameter(p->fprogram, "Texture_FogHeightTexture");
4223                 p->fp_Texture_FogMask            = cgGetNamedParameter(p->fprogram, "Texture_FogMask");
4224                 p->fp_Texture_Lightmap           = cgGetNamedParameter(p->fprogram, "Texture_Lightmap");
4225                 p->fp_Texture_Deluxemap          = cgGetNamedParameter(p->fprogram, "Texture_Deluxemap");
4226                 p->fp_Texture_Attenuation        = cgGetNamedParameter(p->fprogram, "Texture_Attenuation");
4227                 p->fp_Texture_Cube               = cgGetNamedParameter(p->fprogram, "Texture_Cube");
4228                 p->fp_Texture_Refraction         = cgGetNamedParameter(p->fprogram, "Texture_Refraction");
4229                 p->fp_Texture_Reflection         = cgGetNamedParameter(p->fprogram, "Texture_Reflection");
4230                 p->fp_Texture_ShadowMapRect      = cgGetNamedParameter(p->fprogram, "Texture_ShadowMapRect");
4231                 p->fp_Texture_ShadowMapCube      = cgGetNamedParameter(p->fprogram, "Texture_ShadowMapCube");
4232                 p->fp_Texture_ShadowMap2D        = cgGetNamedParameter(p->fprogram, "Texture_ShadowMap2D");
4233                 p->fp_Texture_CubeProjection     = cgGetNamedParameter(p->fprogram, "Texture_CubeProjection");
4234                 p->fp_Texture_ScreenDepth        = cgGetNamedParameter(p->fprogram, "Texture_ScreenDepth");
4235                 p->fp_Texture_ScreenNormalMap    = cgGetNamedParameter(p->fprogram, "Texture_ScreenNormalMap");
4236                 p->fp_Texture_ScreenDiffuse      = cgGetNamedParameter(p->fprogram, "Texture_ScreenDiffuse");
4237                 p->fp_Texture_ScreenSpecular     = cgGetNamedParameter(p->fprogram, "Texture_ScreenSpecular");
4238                 p->fp_Texture_ReflectMask        = cgGetNamedParameter(p->fprogram, "Texture_ReflectMask");
4239                 p->fp_Texture_ReflectCube        = cgGetNamedParameter(p->fprogram, "Texture_ReflectCube");
4240                 p->fp_Alpha                      = cgGetNamedParameter(p->fprogram, "Alpha");
4241                 p->fp_BloomBlur_Parameters       = cgGetNamedParameter(p->fprogram, "BloomBlur_Parameters");
4242                 p->fp_ClientTime                 = cgGetNamedParameter(p->fprogram, "ClientTime");
4243                 p->fp_Color_Ambient              = cgGetNamedParameter(p->fprogram, "Color_Ambient");
4244                 p->fp_Color_Diffuse              = cgGetNamedParameter(p->fprogram, "Color_Diffuse");
4245                 p->fp_Color_Specular             = cgGetNamedParameter(p->fprogram, "Color_Specular");
4246                 p->fp_Color_Glow                 = cgGetNamedParameter(p->fprogram, "Color_Glow");
4247                 p->fp_Color_Pants                = cgGetNamedParameter(p->fprogram, "Color_Pants");
4248                 p->fp_Color_Shirt                = cgGetNamedParameter(p->fprogram, "Color_Shirt");
4249                 p->fp_DeferredColor_Ambient      = cgGetNamedParameter(p->fprogram, "DeferredColor_Ambient");
4250                 p->fp_DeferredColor_Diffuse      = cgGetNamedParameter(p->fprogram, "DeferredColor_Diffuse");
4251                 p->fp_DeferredColor_Specular     = cgGetNamedParameter(p->fprogram, "DeferredColor_Specular");
4252                 p->fp_DeferredMod_Diffuse        = cgGetNamedParameter(p->fprogram, "DeferredMod_Diffuse");
4253                 p->fp_DeferredMod_Specular       = cgGetNamedParameter(p->fprogram, "DeferredMod_Specular");
4254                 p->fp_DistortScaleRefractReflect = cgGetNamedParameter(p->fprogram, "DistortScaleRefractReflect");
4255                 p->fp_EyePosition                = cgGetNamedParameter(p->fprogram, "EyePosition");
4256                 p->fp_FogColor                   = cgGetNamedParameter(p->fprogram, "FogColor");
4257                 p->fp_FogHeightFade              = cgGetNamedParameter(p->fprogram, "FogHeightFade");
4258                 p->fp_FogPlane                   = cgGetNamedParameter(p->fprogram, "FogPlane");
4259                 p->fp_FogPlaneViewDist           = cgGetNamedParameter(p->fprogram, "FogPlaneViewDist");
4260                 p->fp_FogRangeRecip              = cgGetNamedParameter(p->fprogram, "FogRangeRecip");
4261                 p->fp_LightColor                 = cgGetNamedParameter(p->fprogram, "LightColor");
4262                 p->fp_LightDir                   = cgGetNamedParameter(p->fprogram, "LightDir");
4263                 p->fp_LightPosition              = cgGetNamedParameter(p->fprogram, "LightPosition");
4264                 p->fp_OffsetMapping_Scale        = cgGetNamedParameter(p->fprogram, "OffsetMapping_Scale");
4265                 p->fp_PixelSize                  = cgGetNamedParameter(p->fprogram, "PixelSize");
4266                 p->fp_ReflectColor               = cgGetNamedParameter(p->fprogram, "ReflectColor");
4267                 p->fp_ReflectFactor              = cgGetNamedParameter(p->fprogram, "ReflectFactor");
4268                 p->fp_ReflectOffset              = cgGetNamedParameter(p->fprogram, "ReflectOffset");
4269                 p->fp_RefractColor               = cgGetNamedParameter(p->fprogram, "RefractColor");
4270                 p->fp_Saturation                 = cgGetNamedParameter(p->fprogram, "Saturation");
4271                 p->fp_ScreenCenterRefractReflect = cgGetNamedParameter(p->fprogram, "ScreenCenterRefractReflect");
4272                 p->fp_ScreenScaleRefractReflect  = cgGetNamedParameter(p->fprogram, "ScreenScaleRefractReflect");
4273                 p->fp_ScreenToDepth              = cgGetNamedParameter(p->fprogram, "ScreenToDepth");
4274                 p->fp_ShadowMap_Parameters       = cgGetNamedParameter(p->fprogram, "ShadowMap_Parameters");
4275                 p->fp_ShadowMap_TextureScale     = cgGetNamedParameter(p->fprogram, "ShadowMap_TextureScale");
4276                 p->fp_SpecularPower              = cgGetNamedParameter(p->fprogram, "SpecularPower");
4277                 p->fp_UserVec1                   = cgGetNamedParameter(p->fprogram, "UserVec1");
4278                 p->fp_UserVec2                   = cgGetNamedParameter(p->fprogram, "UserVec2");
4279                 p->fp_UserVec3                   = cgGetNamedParameter(p->fprogram, "UserVec3");
4280                 p->fp_UserVec4                   = cgGetNamedParameter(p->fprogram, "UserVec4");
4281                 p->fp_ViewTintColor              = cgGetNamedParameter(p->fprogram, "ViewTintColor");
4282                 p->fp_ViewToLight                = cgGetNamedParameter(p->fprogram, "ViewToLight");
4283                 p->fp_PixelToScreenTexCoord      = cgGetNamedParameter(p->fprogram, "PixelToScreenTexCoord");
4284                 p->fp_ModelToReflectCube         = cgGetNamedParameter(p->fprogram, "ModelToReflectCube");
4285                 CHECKCGERROR
4286         }
4287
4288         if ((p->vprogram || !vertstring[0]) && (p->fprogram || !fragstring[0]))
4289                 Con_DPrintf("^5CG shader %s compiled.\n", permutationname);
4290         else
4291                 Con_Printf("^1CG shader %s failed!  some features may not work properly.\n", permutationname);
4292
4293         // free the strings
4294         if (vertstring)
4295                 Mem_Free(vertstring);
4296         if (geomstring)
4297                 Mem_Free(geomstring);
4298         if (fragstring)
4299                 Mem_Free(fragstring);
4300         if (vertexstring)
4301                 Mem_Free(vertexstring);
4302         if (geometrystring)
4303                 Mem_Free(geometrystring);
4304         if (fragmentstring)
4305                 Mem_Free(fragmentstring);
4306 }
4307
4308 void R_SetupShader_SetPermutationCG(unsigned int mode, unsigned int permutation)
4309 {
4310         r_cg_permutation_t *perm = R_CG_FindPermutation(mode, permutation);
4311         CHECKGLERROR
4312         CHECKCGERROR
4313         if (r_cg_permutation != perm)
4314         {
4315                 r_cg_permutation = perm;
4316                 if (!r_cg_permutation->vprogram && !r_cg_permutation->fprogram)
4317                 {
4318                         if (!r_cg_permutation->compiled)
4319                                 R_CG_CompilePermutation(perm, mode, permutation);
4320                         if (!r_cg_permutation->vprogram && !r_cg_permutation->fprogram)
4321                         {
4322                                 // remove features until we find a valid permutation
4323                                 int i;
4324                                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
4325                                 {
4326                                         // reduce i more quickly whenever it would not remove any bits
4327                                         int j = 1<<(SHADERPERMUTATION_COUNT-1-i);
4328                                         if (!(permutation & j))
4329                                                 continue;
4330                                         permutation -= j;
4331                                         r_cg_permutation = R_CG_FindPermutation(mode, permutation);
4332                                         if (!r_cg_permutation->compiled)
4333                                                 R_CG_CompilePermutation(perm, mode, permutation);
4334                                         if (r_cg_permutation->vprogram || r_cg_permutation->fprogram)
4335                                                 break;
4336                                 }
4337                                 if (i >= SHADERPERMUTATION_COUNT)
4338                                 {
4339                                         //Con_Printf("Could not find a working Cg shader for permutation %s %s\n", shadermodeinfo[mode].vertexfilename, shadermodeinfo[mode].pretext);
4340                                         r_cg_permutation = R_CG_FindPermutation(mode, permutation);
4341                                         return; // no bit left to clear, entire mode is broken
4342                                 }
4343                         }
4344                 }
4345                 CHECKGLERROR
4346                 CHECKCGERROR
4347                 if (r_cg_permutation->vprogram)
4348                 {
4349                         cgGLLoadProgram(r_cg_permutation->vprogram);CHECKCGERROR CHECKGLERROR
4350                         cgGLBindProgram(r_cg_permutation->vprogram);CHECKCGERROR CHECKGLERROR
4351                         cgGLEnableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
4352                 }
4353                 else
4354                 {
4355                         cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
4356                         cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
4357                 }
4358                 if (r_cg_permutation->fprogram)
4359                 {
4360                         cgGLLoadProgram(r_cg_permutation->fprogram);CHECKCGERROR CHECKGLERROR
4361                         cgGLBindProgram(r_cg_permutation->fprogram);CHECKCGERROR CHECKGLERROR
4362                         cgGLEnableProfile(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
4363                 }
4364                 else
4365                 {
4366                         cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
4367                         cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
4368                 }
4369         }
4370         CHECKCGERROR
4371         if (r_cg_permutation->vp_ModelViewProjectionMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewProjectionMatrix, gl_modelviewprojection16f);CHECKCGERROR
4372         if (r_cg_permutation->vp_ModelViewMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewMatrix, gl_modelview16f);CHECKCGERROR
4373         if (r_cg_permutation->fp_ClientTime) cgGLSetParameter1f(r_cg_permutation->fp_ClientTime, cl.time);CHECKCGERROR
4374 }
4375
4376 void CG_BindTexture(CGparameter param, rtexture_t *tex)
4377 {
4378         cgGLSetTextureParameter(param, R_GetTexture(tex));
4379         cgGLEnableTextureParameter(param);
4380 }
4381 #endif
4382
4383 void R_GLSL_Restart_f(void)
4384 {
4385         unsigned int i, limit;
4386         if (glslshaderstring && glslshaderstring != builtinshaderstring)
4387                 Mem_Free(glslshaderstring);
4388         glslshaderstring = NULL;
4389         if (cgshaderstring && cgshaderstring != builtincgshaderstring)
4390                 Mem_Free(cgshaderstring);
4391         cgshaderstring = NULL;
4392         switch(vid.renderpath)
4393         {
4394         case RENDERPATH_GL20:
4395                 {
4396                         r_glsl_permutation_t *p;
4397                         r_glsl_permutation = NULL;
4398                         limit = Mem_ExpandableArray_IndexRange(&r_glsl_permutationarray);
4399                         for (i = 0;i < limit;i++)
4400                         {
4401                                 if ((p = (r_glsl_permutation_t*)Mem_ExpandableArray_RecordAtIndex(&r_glsl_permutationarray, i)))
4402                                 {
4403                                         GL_Backend_FreeProgram(p->program);
4404                                         Mem_ExpandableArray_FreeRecord(&r_glsl_permutationarray, (void*)p);
4405                                 }
4406                         }
4407                         memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash));
4408                 }
4409                 break;
4410         case RENDERPATH_CGGL:
4411 #ifdef SUPPORTCG
4412                 {
4413                         r_cg_permutation_t *p;
4414                         r_cg_permutation = NULL;
4415                         cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
4416                         cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
4417                         cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
4418                         cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
4419                         limit = Mem_ExpandableArray_IndexRange(&r_cg_permutationarray);
4420                         for (i = 0;i < limit;i++)
4421                         {
4422                                 if ((p = (r_cg_permutation_t*)Mem_ExpandableArray_RecordAtIndex(&r_cg_permutationarray, i)))
4423                                 {
4424                                         if (p->vprogram)
4425                                                 cgDestroyProgram(p->vprogram);
4426                                         if (p->fprogram)
4427                                                 cgDestroyProgram(p->fprogram);
4428                                         Mem_ExpandableArray_FreeRecord(&r_cg_permutationarray, (void*)p);
4429                                 }
4430                         }
4431                         memset(r_cg_permutationhash, 0, sizeof(r_cg_permutationhash));
4432                 }
4433                 break;
4434 #endif
4435         case RENDERPATH_GL13:
4436         case RENDERPATH_GL11:
4437                 break;
4438         }
4439 }
4440
4441 void R_GLSL_DumpShader_f(void)
4442 {
4443         int i;
4444         qfile_t *file;
4445
4446         file = FS_OpenRealFile("glsl/default.glsl", "w", false);
4447         if (file)
4448         {
4449                 FS_Print(file, "/* The engine may define the following macros:\n");
4450                 FS_Print(file, "#define VERTEX_SHADER\n#define GEOMETRY_SHADER\n#define FRAGMENT_SHADER\n");
4451                 for (i = 0;i < SHADERMODE_COUNT;i++)
4452                         FS_Print(file, glslshadermodeinfo[i].pretext);
4453                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
4454                         FS_Print(file, shaderpermutationinfo[i].pretext);
4455                 FS_Print(file, "*/\n");
4456                 FS_Print(file, builtinshaderstring);
4457                 FS_Close(file);
4458                 Con_Printf("glsl/default.glsl written\n");
4459         }
4460         else
4461                 Con_Printf("failed to write to glsl/default.glsl\n");
4462
4463 #ifdef SUPPORTCG
4464         file = FS_OpenRealFile("cg/default.cg", "w", false);
4465         if (file)
4466         {
4467                 FS_Print(file, "/* The engine may define the following macros:\n");
4468                 FS_Print(file, "#define VERTEX_SHADER\n#define GEOMETRY_SHADER\n#define FRAGMENT_SHADER\n");
4469                 for (i = 0;i < SHADERMODE_COUNT;i++)
4470                         FS_Print(file, cgshadermodeinfo[i].pretext);
4471                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
4472                         FS_Print(file, shaderpermutationinfo[i].pretext);
4473                 FS_Print(file, "*/\n");
4474                 FS_Print(file, builtincgshaderstring);
4475                 FS_Close(file);
4476                 Con_Printf("cg/default.cg written\n");
4477         }
4478         else
4479                 Con_Printf("failed to write to cg/default.cg\n");
4480 #endif
4481 }
4482
4483 void R_SetupShader_Generic(rtexture_t *first, rtexture_t *second, int texturemode, int rgbscale)
4484 {
4485         if (!second)
4486                 texturemode = GL_MODULATE;
4487         switch (vid.renderpath)
4488         {
4489         case RENDERPATH_GL20:
4490                 R_SetupShader_SetPermutationGLSL(SHADERMODE_GENERIC, (first ? SHADERPERMUTATION_DIFFUSE : 0) | (second ? SHADERPERMUTATION_SPECULAR : 0) | (r_shadow_glossexact.integer ? SHADERPERMUTATION_EXACTSPECULARMATH : 0) | (texturemode == GL_MODULATE ? SHADERPERMUTATION_COLORMAPPING : (texturemode == GL_ADD ? SHADERPERMUTATION_GLOW : (texturemode == GL_DECAL ? SHADERPERMUTATION_VERTEXTEXTUREBLEND : 0))));
4491                 if (r_glsl_permutation->loc_Texture_First ) R_Mesh_TexBind(GL20TU_FIRST , first );
4492                 if (r_glsl_permutation->loc_Texture_Second) R_Mesh_TexBind(GL20TU_SECOND, second);
4493                 break;
4494         case RENDERPATH_CGGL:
4495 #ifdef SUPPORTCG
4496                 CHECKCGERROR
4497                 R_SetupShader_SetPermutationCG(SHADERMODE_GENERIC, (first ? SHADERPERMUTATION_DIFFUSE : 0) | (second ? SHADERPERMUTATION_SPECULAR : 0) | (r_shadow_glossexact.integer ? SHADERPERMUTATION_EXACTSPECULARMATH : 0) | (texturemode == GL_MODULATE ? SHADERPERMUTATION_COLORMAPPING : (texturemode == GL_ADD ? SHADERPERMUTATION_GLOW : (texturemode == GL_DECAL ? SHADERPERMUTATION_VERTEXTEXTUREBLEND : 0))));
4498                 if (r_cg_permutation->fp_Texture_First ) CG_BindTexture(r_cg_permutation->fp_Texture_First , first );CHECKCGERROR
4499                 if (r_cg_permutation->fp_Texture_Second) CG_BindTexture(r_cg_permutation->fp_Texture_Second, second);CHECKCGERROR
4500 #endif
4501                 break;
4502         case RENDERPATH_GL13:
4503                 R_Mesh_TexBind(0, first );
4504                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
4505                 R_Mesh_TexBind(1, second);
4506                 if (second)
4507                         R_Mesh_TexCombine(1, texturemode, texturemode, rgbscale, 1);
4508                 break;
4509         case RENDERPATH_GL11:
4510                 R_Mesh_TexBind(0, first );
4511                 break;
4512         }
4513 }
4514
4515 void R_SetupShader_DepthOrShadow(void)
4516 {
4517         switch (vid.renderpath)
4518         {
4519         case RENDERPATH_GL20:
4520                 R_SetupShader_SetPermutationGLSL(SHADERMODE_DEPTH_OR_SHADOW, 0);
4521                 break;
4522         case RENDERPATH_CGGL:
4523 #ifdef SUPPORTCG
4524                 R_SetupShader_SetPermutationCG(SHADERMODE_DEPTH_OR_SHADOW, 0);
4525 #endif
4526                 break;
4527         case RENDERPATH_GL13:
4528                 R_Mesh_TexBind(0, 0);
4529                 R_Mesh_TexBind(1, 0);
4530                 break;
4531         case RENDERPATH_GL11:
4532                 R_Mesh_TexBind(0, 0);
4533                 break;
4534         }
4535 }
4536
4537 void R_SetupShader_ShowDepth(void)
4538 {
4539         switch (vid.renderpath)
4540         {
4541         case RENDERPATH_GL20:
4542                 R_SetupShader_SetPermutationGLSL(SHADERMODE_SHOWDEPTH, 0);
4543                 break;
4544         case RENDERPATH_CGGL:
4545 #ifdef SUPPORTCG
4546                 R_SetupShader_SetPermutationCG(SHADERMODE_SHOWDEPTH, 0);
4547 #endif
4548                 break;
4549         case RENDERPATH_GL13:
4550                 break;
4551         case RENDERPATH_GL11:
4552                 break;
4553         }
4554 }
4555
4556 extern qboolean r_shadow_usingdeferredprepass;
4557 extern cvar_t r_shadow_deferred_8bitrange;
4558 extern rtexture_t *r_shadow_attenuationgradienttexture;
4559 extern rtexture_t *r_shadow_attenuation2dtexture;
4560 extern rtexture_t *r_shadow_attenuation3dtexture;
4561 extern qboolean r_shadow_usingshadowmaprect;
4562 extern qboolean r_shadow_usingshadowmapcube;
4563 extern qboolean r_shadow_usingshadowmap2d;
4564 extern qboolean r_shadow_usingshadowmaportho;
4565 extern float r_shadow_shadowmap_texturescale[2];
4566 extern float r_shadow_shadowmap_parameters[4];
4567 extern qboolean r_shadow_shadowmapvsdct;
4568 extern qboolean r_shadow_shadowmapsampler;
4569 extern int r_shadow_shadowmappcf;
4570 extern rtexture_t *r_shadow_shadowmaprectangletexture;
4571 extern rtexture_t *r_shadow_shadowmap2dtexture;
4572 extern rtexture_t *r_shadow_shadowmapcubetexture[R_SHADOW_SHADOWMAP_NUMCUBEMAPS];
4573 extern rtexture_t *r_shadow_shadowmapvsdcttexture;
4574 extern matrix4x4_t r_shadow_shadowmapmatrix;
4575 extern int r_shadow_shadowmaplod; // changes for each light based on distance
4576 extern int r_shadow_prepass_width;
4577 extern int r_shadow_prepass_height;
4578 extern rtexture_t *r_shadow_prepassgeometrydepthtexture;
4579 extern rtexture_t *r_shadow_prepassgeometrynormalmaptexture;
4580 extern rtexture_t *r_shadow_prepasslightingdiffusetexture;
4581 extern rtexture_t *r_shadow_prepasslightingspeculartexture;
4582 static qboolean R_BlendFuncAllowsColormod(int src, int dst)
4583 {
4584         // a blendfunc allows colormod if:
4585         // a) it can never keep the destination pixel invariant, or
4586         // b) it can keep the destination pixel invariant, and still can do so if colormodded
4587         // this is to prevent unintended side effects from colormod
4588
4589         // in formulas:
4590         // IF there is a (s, sa) for which for all (d, da),
4591         //   s * src(s, d, sa, da) + d * dst(s, d, sa, da) == d
4592         // THEN, for this (s, sa) and all (colormod, d, da):
4593         //   s*colormod * src(s*colormod, d, sa, da) + d * dst(s*colormod, d, sa, da) == d
4594         // OBVIOUSLY, this means that
4595         //   s*colormod * src(s*colormod, d, sa, da) = 0
4596         //   dst(s*colormod, d, sa, da)              = 1
4597
4598         // note: not caring about GL_SRC_ALPHA_SATURATE and following here, these are unused in DP code
4599
4600         // main condition to leave dst color invariant:
4601         //   s * src(s, d, sa, da) + d * dst(s, d, sa, da) == d
4602         //   src == GL_ZERO:
4603         //     s * 0 + d * dst(s, d, sa, da) == d
4604         //       => dst == GL_ONE/GL_SRC_COLOR/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
4605         //       => colormod is a problem for GL_SRC_COLOR only
4606         //   src == GL_ONE:
4607         //     s + d * dst(s, d, sa, da) == d
4608         //       => s == 0
4609         //       => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
4610         //       => colormod is never problematic for these
4611         //   src == GL_SRC_COLOR:
4612         //     s*s + d * dst(s, d, sa, da) == d
4613         //       => s == 0
4614         //       => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
4615         //       => colormod is never problematic for these
4616         //   src == GL_ONE_MINUS_SRC_COLOR:
4617         //     s*(1-s) + d * dst(s, d, sa, da) == d
4618         //       => s == 0 or s == 1
4619         //       => dst == GL_ONE/GL_SRC_COLOR/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
4620         //       => colormod is a problem for GL_SRC_COLOR only
4621         //   src == GL_DST_COLOR
4622         //     s*d + d * dst(s, d, sa, da) == d
4623         //       => s == 1
4624         //       => dst == GL_ZERO/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
4625         //       => colormod is always a problem
4626         //     or
4627         //       => s == 0
4628         //       => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
4629         //       => colormod is never problematic for these
4630         //       => BUT, we do not know s! We must assume it is problematic
4631         //       then... except in GL_ONE case, where we know all invariant
4632         //       cases are fine
4633         //   src == GL_ONE_MINUS_DST_COLOR
4634         //     s*(1-d) + d * dst(s, d, sa, da) == d
4635         //       => s == 0 (1-d is impossible to handle for our desired result)
4636         //       => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
4637         //       => colormod is never problematic for these
4638         //   src == GL_SRC_ALPHA
4639         //     s*sa + d * dst(s, d, sa, da) == d
4640         //       => s == 0, or sa == 0
4641         //       => dst == GL_ONE/GL_SRC_COLOR/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
4642         //       => colormod breaks in the case GL_SRC_COLOR only
4643         //   src == GL_ONE_MINUS_SRC_ALPHA
4644         //     s*(1-sa) + d * dst(s, d, sa, da) == d
4645         //       => s == 0, or sa == 1
4646         //       => dst == GL_ONE/GL_SRC_COLOR/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
4647         //       => colormod breaks in the case GL_SRC_COLOR only
4648         //   src == GL_DST_ALPHA
4649         //     s*da + d * dst(s, d, sa, da) == d
4650         //       => s == 0
4651         //       => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
4652         //       => colormod is never problematic for these
4653
4654         switch(src)
4655         {
4656                 case GL_ZERO:
4657                 case GL_ONE_MINUS_SRC_COLOR:
4658                 case GL_SRC_ALPHA:
4659                 case GL_ONE_MINUS_SRC_ALPHA:
4660                         if(dst == GL_SRC_COLOR)
4661                                 return false;
4662                         return true;
4663                 case GL_ONE:
4664                 case GL_SRC_COLOR:
4665                 case GL_ONE_MINUS_DST_COLOR:
4666                 case GL_DST_ALPHA:
4667                 case GL_ONE_MINUS_DST_ALPHA:
4668                         return true;
4669                 case GL_DST_COLOR:
4670                         if(dst == GL_ONE)
4671                                 return true;
4672                         return false;
4673                 default:
4674                         return false;
4675         }
4676 }
4677 void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, float ambientscale, float diffusescale, float specularscale, rsurfacepass_t rsurfacepass)
4678 {
4679         // select a permutation of the lighting shader appropriate to this
4680         // combination of texture, entity, light source, and fogging, only use the
4681         // minimum features necessary to avoid wasting rendering time in the
4682         // fragment shader on features that are not being used
4683         unsigned int permutation = 0;
4684         unsigned int mode = 0;
4685         qboolean allow_colormod;
4686         static float dummy_colormod[3] = {1, 1, 1};
4687         float *colormod = rsurface.colormod;
4688         float m16f[16];
4689         if (rsurfacepass == RSURFPASS_BACKGROUND)
4690         {
4691                 // distorted background
4692                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
4693                         mode = SHADERMODE_WATER;
4694                 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFRACTION)
4695                         mode = SHADERMODE_REFRACTION;
4696                 else
4697                 {
4698                         mode = SHADERMODE_GENERIC;
4699                         permutation |= SHADERPERMUTATION_DIFFUSE;
4700                 }
4701                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
4702                 R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
4703                 R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
4704                 R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
4705                 R_Mesh_TexCoordPointer(4, 0, NULL, 0, 0);
4706                 R_Mesh_ColorPointer(NULL, 0, 0);
4707                 GL_AlphaTest(false);
4708                 GL_BlendFunc(GL_ONE, GL_ZERO);
4709                 allow_colormod = R_BlendFuncAllowsColormod(GL_ONE, GL_ZERO);
4710         }
4711         else if (rsurfacepass == RSURFPASS_DEFERREDGEOMETRY)
4712         {
4713                 if (r_glsl_offsetmapping.integer)
4714                 {
4715                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
4716                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
4717                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
4718                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
4719                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
4720                         {
4721                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
4722                                 if (r_glsl_offsetmapping_reliefmapping.integer)
4723                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
4724                         }
4725                 }
4726                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
4727                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
4728                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
4729                         permutation |= SHADERPERMUTATION_ALPHAKILL;
4730                 // normalmap (deferred prepass), may use alpha test on diffuse
4731                 mode = SHADERMODE_DEFERREDGEOMETRY;
4732                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
4733                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
4734                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
4735                 R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
4736                 R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
4737                 R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
4738                 R_Mesh_TexCoordPointer(4, 0, NULL, 0, 0);
4739                 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND)
4740                         R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
4741                 else
4742                         R_Mesh_ColorPointer(NULL, 0, 0);
4743                 GL_AlphaTest(false);
4744                 GL_BlendFunc(GL_ONE, GL_ZERO);
4745                 allow_colormod = R_BlendFuncAllowsColormod(GL_ONE, GL_ZERO);
4746         }
4747         else if (rsurfacepass == RSURFPASS_RTLIGHT)
4748         {
4749                 if (r_glsl_offsetmapping.integer)
4750                 {
4751                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
4752                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
4753                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
4754                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
4755                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
4756                         {
4757                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
4758                                 if (r_glsl_offsetmapping_reliefmapping.integer)
4759                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
4760                         }
4761                 }
4762                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
4763                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
4764                 // light source
4765                 mode = SHADERMODE_LIGHTSOURCE;
4766                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
4767                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
4768                 if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
4769                         permutation |= SHADERPERMUTATION_CUBEFILTER;
4770                 if (diffusescale > 0)
4771                         permutation |= SHADERPERMUTATION_DIFFUSE;
4772                 if (specularscale > 0)
4773                 {
4774                         permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
4775                         if (r_shadow_glossexact.integer)
4776                                 permutation |= SHADERPERMUTATION_EXACTSPECULARMATH;
4777                 }
4778                 if (r_refdef.fogenabled)
4779                         permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
4780                 if (rsurface.texture->colormapping)
4781                         permutation |= SHADERPERMUTATION_COLORMAPPING;
4782                 if (r_shadow_usingshadowmaprect || r_shadow_usingshadowmap2d || r_shadow_usingshadowmapcube)
4783                 {
4784                         if (r_shadow_usingshadowmaprect)
4785                                 permutation |= SHADERPERMUTATION_SHADOWMAPRECT;
4786                         if (r_shadow_usingshadowmap2d)
4787                                 permutation |= SHADERPERMUTATION_SHADOWMAP2D;
4788                         if (r_shadow_usingshadowmapcube)
4789                                 permutation |= SHADERPERMUTATION_SHADOWMAPCUBE;
4790                         else if(r_shadow_shadowmapvsdct)
4791                                 permutation |= SHADERPERMUTATION_SHADOWMAPVSDCT;
4792
4793                         if (r_shadow_shadowmapsampler)
4794                                 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
4795                         if (r_shadow_shadowmappcf > 1)
4796                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
4797                         else if (r_shadow_shadowmappcf)
4798                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
4799                 }
4800                 if (rsurface.texture->reflectmasktexture)
4801                         permutation |= SHADERPERMUTATION_REFLECTCUBE;
4802                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
4803                 if (true || permutation & (SHADERPERMUTATION_DIFFUSE | SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_OFFSETMAPPING))
4804                 {
4805                         R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
4806                         R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
4807                         R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
4808                 }
4809                 else
4810                 {
4811                         R_Mesh_TexCoordPointer(1, 0, NULL, 0, 0);
4812                         R_Mesh_TexCoordPointer(2, 0, NULL, 0, 0);
4813                         R_Mesh_TexCoordPointer(3, 0, NULL, 0, 0);
4814                 }
4815                 //R_Mesh_TexCoordPointer(4, 0, NULL, 0, 0);
4816                 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND)
4817                         R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
4818                 else
4819                         R_Mesh_ColorPointer(NULL, 0, 0);
4820                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
4821                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
4822                 allow_colormod = R_BlendFuncAllowsColormod(GL_SRC_ALPHA, GL_ONE);
4823         }
4824         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
4825         {
4826                 if (r_glsl_offsetmapping.integer)
4827                 {
4828                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
4829                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
4830                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
4831                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
4832                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
4833                         {
4834                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
4835                                 if (r_glsl_offsetmapping_reliefmapping.integer)
4836                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
4837                         }
4838                 }
4839                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
4840                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
4841                 // unshaded geometry (fullbright or ambient model lighting)
4842                 mode = SHADERMODE_FLATCOLOR;
4843                 ambientscale = diffusescale = specularscale = 0;
4844                 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
4845                         permutation |= SHADERPERMUTATION_GLOW;
4846                 if (r_refdef.fogenabled)
4847                         permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
4848                 if (rsurface.texture->colormapping)
4849                         permutation |= SHADERPERMUTATION_COLORMAPPING;
4850                 if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
4851                 {
4852                         permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
4853                         if (r_shadow_usingshadowmaprect)
4854                                 permutation |= SHADERPERMUTATION_SHADOWMAPRECT;
4855                         if (r_shadow_usingshadowmap2d)
4856                                 permutation |= SHADERPERMUTATION_SHADOWMAP2D;
4857
4858                         if (r_shadow_shadowmapsampler)
4859                                 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
4860                         if (r_shadow_shadowmappcf > 1)
4861                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
4862                         else if (r_shadow_shadowmappcf)
4863                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
4864                 }
4865                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
4866                         permutation |= SHADERPERMUTATION_REFLECTION;
4867                 if (rsurface.texture->reflectmasktexture)
4868                         permutation |= SHADERPERMUTATION_REFLECTCUBE;
4869                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
4870                 if (true || permutation & (SHADERPERMUTATION_DIFFUSE | SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_OFFSETMAPPING))
4871                 {
4872                         R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
4873                         R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
4874                         R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
4875                 }
4876                 else
4877                 {
4878                         R_Mesh_TexCoordPointer(1, 0, NULL, 0, 0);
4879                         R_Mesh_TexCoordPointer(2, 0, NULL, 0, 0);
4880                         R_Mesh_TexCoordPointer(3, 0, NULL, 0, 0);
4881                 }
4882                 R_Mesh_TexCoordPointer(4, 0, NULL, 0, 0);
4883                 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND)
4884                         R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
4885                 else
4886                         R_Mesh_ColorPointer(NULL, 0, 0);
4887                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
4888                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
4889                 allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
4890         }
4891         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT_DIRECTIONAL)
4892         {
4893                 if (r_glsl_offsetmapping.integer)
4894                 {
4895                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
4896                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
4897                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
4898                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
4899                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
4900                         {
4901                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
4902                                 if (r_glsl_offsetmapping_reliefmapping.integer)
4903                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
4904                         }
4905                 }
4906                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
4907                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
4908                 // directional model lighting
4909                 mode = SHADERMODE_LIGHTDIRECTION;
4910                 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
4911                         permutation |= SHADERPERMUTATION_GLOW;
4912                 permutation |= SHADERPERMUTATION_DIFFUSE;
4913                 if (specularscale > 0)
4914                 {
4915                         permutation |= SHADERPERMUTATION_SPECULAR;
4916                         if (r_shadow_glossexact.integer)
4917                                 permutation |= SHADERPERMUTATION_EXACTSPECULARMATH;
4918                 }
4919                 if (r_refdef.fogenabled)
4920                         permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
4921                 if (rsurface.texture->colormapping)
4922                         permutation |= SHADERPERMUTATION_COLORMAPPING;
4923                 if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
4924                 {
4925                         permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
4926                         if (r_shadow_usingshadowmaprect)
4927                                 permutation |= SHADERPERMUTATION_SHADOWMAPRECT;
4928                         if (r_shadow_usingshadowmap2d)
4929                                 permutation |= SHADERPERMUTATION_SHADOWMAP2D;
4930
4931                         if (r_shadow_shadowmapsampler)
4932                                 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
4933                         if (r_shadow_shadowmappcf > 1)
4934                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
4935                         else if (r_shadow_shadowmappcf)
4936                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
4937                 }
4938                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
4939                         permutation |= SHADERPERMUTATION_REFLECTION;
4940                 if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED))
4941                         permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
4942                 if (rsurface.texture->reflectmasktexture)
4943                         permutation |= SHADERPERMUTATION_REFLECTCUBE;
4944                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
4945                 if (true || permutation & (SHADERPERMUTATION_DIFFUSE | SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_OFFSETMAPPING))
4946                 {
4947                         R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
4948                         R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
4949                         R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
4950                 }
4951                 else
4952                 {
4953                         R_Mesh_TexCoordPointer(1, 0, NULL, 0, 0);
4954                         R_Mesh_TexCoordPointer(2, 0, NULL, 0, 0);
4955                         R_Mesh_TexCoordPointer(3, 0, NULL, 0, 0);
4956                 }
4957                 R_Mesh_TexCoordPointer(4, 0, NULL, 0, 0);
4958                 R_Mesh_ColorPointer(NULL, 0, 0);
4959                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
4960                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
4961                 allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
4962         }
4963         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
4964         {
4965                 if (r_glsl_offsetmapping.integer)
4966                 {
4967                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
4968                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
4969                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
4970                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
4971                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
4972                         {
4973                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
4974                                 if (r_glsl_offsetmapping_reliefmapping.integer)
4975                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
4976                         }
4977                 }
4978                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
4979                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
4980                 // ambient model lighting
4981                 mode = SHADERMODE_LIGHTDIRECTION;
4982                 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
4983                         permutation |= SHADERPERMUTATION_GLOW;
4984                 if (r_refdef.fogenabled)
4985                         permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
4986                 if (rsurface.texture->colormapping)
4987                         permutation |= SHADERPERMUTATION_COLORMAPPING;
4988                 if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
4989                 {
4990                         permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
4991                         if (r_shadow_usingshadowmaprect)
4992                                 permutation |= SHADERPERMUTATION_SHADOWMAPRECT;
4993                         if (r_shadow_usingshadowmap2d)
4994                                 permutation |= SHADERPERMUTATION_SHADOWMAP2D;
4995
4996                         if (r_shadow_shadowmapsampler)
4997                                 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
4998                         if (r_shadow_shadowmappcf > 1)
4999                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
5000                         else if (r_shadow_shadowmappcf)
5001                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
5002                 }
5003                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
5004                         permutation |= SHADERPERMUTATION_REFLECTION;
5005                 if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED))
5006                         permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
5007                 if (rsurface.texture->reflectmasktexture)
5008                         permutation |= SHADERPERMUTATION_REFLECTCUBE;
5009                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
5010                 if (true || permutation & (SHADERPERMUTATION_DIFFUSE | SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_OFFSETMAPPING))
5011                 {
5012                         R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
5013                         R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
5014                         R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
5015                 }
5016                 else
5017                 {
5018                         R_Mesh_TexCoordPointer(1, 0, NULL, 0, 0);
5019                         R_Mesh_TexCoordPointer(2, 0, NULL, 0, 0);
5020                         R_Mesh_TexCoordPointer(3, 0, NULL, 0, 0);
5021                 }
5022                 R_Mesh_TexCoordPointer(4, 0, NULL, 0, 0);
5023                 R_Mesh_ColorPointer(NULL, 0, 0);
5024                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5025                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5026                 allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5027         }
5028         else
5029         {
5030                 if (r_glsl_offsetmapping.integer)
5031                 {
5032                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
5033                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5034                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
5035                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5036                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
5037                         {
5038                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5039                                 if (r_glsl_offsetmapping_reliefmapping.integer)
5040                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5041                         }
5042                 }
5043                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
5044                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
5045                 // lightmapped wall
5046                 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
5047                         permutation |= SHADERPERMUTATION_GLOW;
5048                 if (r_refdef.fogenabled)
5049                         permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
5050                 if (rsurface.texture->colormapping)
5051                         permutation |= SHADERPERMUTATION_COLORMAPPING;
5052                 if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
5053                 {
5054                         permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
5055                         if (r_shadow_usingshadowmaprect)
5056                                 permutation |= SHADERPERMUTATION_SHADOWMAPRECT;
5057                         if (r_shadow_usingshadowmap2d)
5058                                 permutation |= SHADERPERMUTATION_SHADOWMAP2D;
5059
5060                         if (r_shadow_shadowmapsampler)
5061                                 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
5062                         if (r_shadow_shadowmappcf > 1)
5063                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
5064                         else if (r_shadow_shadowmappcf)
5065                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
5066                 }
5067                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
5068                         permutation |= SHADERPERMUTATION_REFLECTION;
5069                 if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED))
5070                         permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
5071                 if (rsurface.texture->reflectmasktexture)
5072                         permutation |= SHADERPERMUTATION_REFLECTCUBE;
5073                 if (r_glsl_deluxemapping.integer >= 1 && rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping)
5074                 {
5075                         // deluxemapping (light direction texture)
5076                         if (rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping && r_refdef.scene.worldmodel->brushq3.deluxemapping_modelspace)
5077                                 mode = SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE;
5078                         else
5079                                 mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
5080                         permutation |= SHADERPERMUTATION_DIFFUSE;
5081                         if (specularscale > 0)
5082                         {
5083                                 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
5084                                 if (r_shadow_glossexact.integer)
5085                                         permutation |= SHADERPERMUTATION_EXACTSPECULARMATH;
5086                         }
5087                         R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
5088                         if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND)
5089                                 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
5090                         else
5091                                 R_Mesh_ColorPointer(NULL, 0, 0);
5092                 }
5093                 else if (r_glsl_deluxemapping.integer >= 2)
5094                 {
5095                         // fake deluxemapping (uniform light direction in tangentspace)
5096                         mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
5097                         permutation |= SHADERPERMUTATION_DIFFUSE;
5098                         if (specularscale > 0)
5099                         {
5100                                 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
5101                                 if (r_shadow_glossexact.integer)
5102                                         permutation |= SHADERPERMUTATION_EXACTSPECULARMATH;
5103                         }
5104                         R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
5105                         if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND)
5106                                 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
5107                         else
5108                                 R_Mesh_ColorPointer(NULL, 0, 0);
5109                 }
5110                 else if (rsurface.uselightmaptexture)
5111                 {
5112                         // ordinary lightmapping (q1bsp, q3bsp)
5113                         mode = SHADERMODE_LIGHTMAP;
5114                         R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
5115                         if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND)
5116                                 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
5117                         else
5118                                 R_Mesh_ColorPointer(NULL, 0, 0);
5119                 }
5120                 else
5121                 {
5122                         // ordinary vertex coloring (q3bsp)
5123                         mode = SHADERMODE_VERTEXCOLOR;
5124                         R_Mesh_TexCoordPointer(4, 0, NULL, 0, 0);
5125                         R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
5126                 }
5127                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
5128                 if (true || permutation & (SHADERPERMUTATION_DIFFUSE | SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_OFFSETMAPPING))
5129                 {
5130                         R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
5131                         R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
5132                         R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
5133                 }
5134                 else
5135                 {
5136                         R_Mesh_TexCoordPointer(1, 0, NULL, 0, 0);
5137                         R_Mesh_TexCoordPointer(2, 0, NULL, 0, 0);
5138                         R_Mesh_TexCoordPointer(3, 0, NULL, 0, 0);
5139                 }
5140                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5141                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5142                 allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5143         }
5144         if(!allow_colormod)
5145                 colormod = dummy_colormod;
5146         switch(vid.renderpath)
5147         {
5148         case RENDERPATH_GL20:
5149                 R_SetupShader_SetPermutationGLSL(mode, permutation);
5150                 if (r_glsl_permutation->loc_ModelToReflectCube >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.matrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelToReflectCube, 1, false, m16f);}
5151                 if (mode == SHADERMODE_LIGHTSOURCE)
5152                 {
5153                         if (r_glsl_permutation->loc_ModelToLight >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelToLight, 1, false, m16f);}
5154                         if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
5155                         if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);
5156                         if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, colormod[0] * ambientscale, colormod[1] * ambientscale, colormod[2] * ambientscale);
5157                         if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Diffuse, colormod[0] * diffusescale, colormod[1] * diffusescale, colormod[2] * diffusescale);
5158                         if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Specular, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale);
5159
5160                         // additive passes are only darkened by fog, not tinted
5161                         if (r_glsl_permutation->loc_FogColor >= 0)
5162                                 qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
5163                         if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));
5164                 }
5165                 else
5166                 {
5167                         if (mode == SHADERMODE_FLATCOLOR)
5168                         {
5169                                 if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, colormod[0], colormod[1], colormod[2]);
5170                         }
5171                         else if (mode == SHADERMODE_LIGHTDIRECTION)
5172                         {
5173                                 if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, (r_refdef.scene.ambient + rsurface.modellight_ambient[0] * r_refdef.lightmapintensity) * colormod[0], (r_refdef.scene.ambient + rsurface.modellight_ambient[1] * r_refdef.lightmapintensity) * colormod[1], (r_refdef.scene.ambient + rsurface.modellight_ambient[2] * r_refdef.lightmapintensity) * colormod[2]);
5174                                 if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Diffuse, r_refdef.lightmapintensity * colormod[0], r_refdef.lightmapintensity * colormod[1], r_refdef.lightmapintensity * colormod[2]);
5175                                 if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale);
5176                                 if (r_glsl_permutation->loc_DeferredMod_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_DeferredMod_Diffuse, colormod[0] * r_shadow_deferred_8bitrange.value, colormod[1] * r_shadow_deferred_8bitrange.value, colormod[2] * r_shadow_deferred_8bitrange.value);
5177                                 if (r_glsl_permutation->loc_DeferredMod_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value);
5178                                 if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, rsurface.modellight_diffuse[0], rsurface.modellight_diffuse[1], rsurface.modellight_diffuse[2]);
5179                                 if (r_glsl_permutation->loc_LightDir >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);
5180                         }
5181                         else
5182                         {
5183                                 if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, r_refdef.scene.ambient * colormod[0], r_refdef.scene.ambient * colormod[1], r_refdef.scene.ambient * colormod[2]);
5184                                 if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Diffuse, rsurface.texture->lightmapcolor[0], rsurface.texture->lightmapcolor[1], rsurface.texture->lightmapcolor[2]);
5185                                 if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale);
5186                                 if (r_glsl_permutation->loc_DeferredMod_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_DeferredMod_Diffuse, colormod[0] * diffusescale * r_shadow_deferred_8bitrange.value, colormod[1] * diffusescale * r_shadow_deferred_8bitrange.value, colormod[2] * diffusescale * r_shadow_deferred_8bitrange.value);
5187                                 if (r_glsl_permutation->loc_DeferredMod_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value);
5188                         }
5189                         // additive passes are only darkened by fog, not tinted
5190                         if (r_glsl_permutation->loc_FogColor >= 0)
5191                         {
5192                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
5193                                         qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
5194                                 else
5195                                         qglUniform3fARB(r_glsl_permutation->loc_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
5196                         }
5197                         if (r_glsl_permutation->loc_DistortScaleRefractReflect >= 0) qglUniform4fARB(r_glsl_permutation->loc_DistortScaleRefractReflect, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor);
5198                         if (r_glsl_permutation->loc_ScreenScaleRefractReflect >= 0) qglUniform4fARB(r_glsl_permutation->loc_ScreenScaleRefractReflect, r_waterstate.screenscale[0], r_waterstate.screenscale[1], r_waterstate.screenscale[0], r_waterstate.screenscale[1]);
5199                         if (r_glsl_permutation->loc_ScreenCenterRefractReflect >= 0) qglUniform4fARB(r_glsl_permutation->loc_ScreenCenterRefractReflect, r_waterstate.screencenter[0], r_waterstate.screencenter[1], r_waterstate.screencenter[0], r_waterstate.screencenter[1]);
5200                         if (r_glsl_permutation->loc_RefractColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_RefractColor, 1, rsurface.texture->refractcolor4f);
5201                         if (r_glsl_permutation->loc_ReflectColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_ReflectColor, 1, rsurface.texture->reflectcolor4f);
5202                         if (r_glsl_permutation->loc_ReflectFactor >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);
5203                         if (r_glsl_permutation->loc_ReflectOffset >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectOffset, rsurface.texture->reflectmin);
5204                         if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));
5205                 }
5206                 if (r_glsl_permutation->loc_TexMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currenttexmatrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_TexMatrix, 1, false, m16f);}
5207                 if (r_glsl_permutation->loc_BackgroundTexMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currentbackgroundtexmatrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_BackgroundTexMatrix, 1, false, m16f);}
5208                 if (r_glsl_permutation->loc_ShadowMapMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&r_shadow_shadowmapmatrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_ShadowMapMatrix, 1, false, m16f);}
5209                 if (r_glsl_permutation->loc_ShadowMap_TextureScale >= 0) qglUniform2fARB(r_glsl_permutation->loc_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);
5210                 if (r_glsl_permutation->loc_ShadowMap_Parameters >= 0) qglUniform4fARB(r_glsl_permutation->loc_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);
5211
5212                 if (r_glsl_permutation->loc_Color_Glow >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]);
5213                 if (r_glsl_permutation->loc_Alpha >= 0) qglUniform1fARB(r_glsl_permutation->loc_Alpha, rsurface.texture->lightmapcolor[3]);
5214                 if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);
5215                 if (r_glsl_permutation->loc_Color_Pants >= 0)
5216                 {
5217                         if (rsurface.texture->pantstexture)
5218                                 qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
5219                         else
5220                                 qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, 0, 0, 0);
5221                 }
5222                 if (r_glsl_permutation->loc_Color_Shirt >= 0)
5223                 {
5224                         if (rsurface.texture->shirttexture)
5225                                 qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
5226                         else
5227                                 qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, 0, 0, 0);
5228                 }
5229                 if (r_glsl_permutation->loc_FogPlane >= 0) qglUniform4fARB(r_glsl_permutation->loc_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]);
5230                 if (r_glsl_permutation->loc_FogPlaneViewDist >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogPlaneViewDist, rsurface.fogplaneviewdist);
5231                 if (r_glsl_permutation->loc_FogRangeRecip >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogRangeRecip, rsurface.fograngerecip);
5232                 if (r_glsl_permutation->loc_FogHeightFade >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogHeightFade, rsurface.fogheightfade);
5233                 if (r_glsl_permutation->loc_OffsetMapping_Scale >= 0) qglUniform1fARB(r_glsl_permutation->loc_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value*rsurface.texture->offsetscale);
5234                 if (r_glsl_permutation->loc_ScreenToDepth >= 0) qglUniform2fARB(r_glsl_permutation->loc_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);
5235                 if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
5236
5237         //      if (r_glsl_permutation->loc_Texture_First           >= 0) R_Mesh_TexBind(GL20TU_FIRST             , r_texture_white                                     );
5238         //      if (r_glsl_permutation->loc_Texture_Second          >= 0) R_Mesh_TexBind(GL20TU_SECOND            , r_texture_white                                     );
5239         //      if (r_glsl_permutation->loc_Texture_GammaRamps      >= 0) R_Mesh_TexBind(GL20TU_GAMMARAMPS        , r_texture_gammaramps                                );
5240                 if (r_glsl_permutation->loc_Texture_Normal          >= 0) R_Mesh_TexBind(GL20TU_NORMAL            , rsurface.texture->nmaptexture                       );
5241                 if (r_glsl_permutation->loc_Texture_Color           >= 0) R_Mesh_TexBind(GL20TU_COLOR             , rsurface.texture->basetexture                       );
5242                 if (r_glsl_permutation->loc_Texture_Gloss           >= 0) R_Mesh_TexBind(GL20TU_GLOSS             , rsurface.texture->glosstexture                      );
5243                 if (r_glsl_permutation->loc_Texture_Glow            >= 0) R_Mesh_TexBind(GL20TU_GLOW              , rsurface.texture->glowtexture                       );
5244                 if (r_glsl_permutation->loc_Texture_SecondaryNormal >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_NORMAL  , rsurface.texture->backgroundnmaptexture             );
5245                 if (r_glsl_permutation->loc_Texture_SecondaryColor  >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_COLOR   , rsurface.texture->backgroundbasetexture             );
5246                 if (r_glsl_permutation->loc_Texture_SecondaryGloss  >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_GLOSS   , rsurface.texture->backgroundglosstexture            );
5247                 if (r_glsl_permutation->loc_Texture_SecondaryGlow   >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_GLOW    , rsurface.texture->backgroundglowtexture             );
5248                 if (r_glsl_permutation->loc_Texture_Pants           >= 0) R_Mesh_TexBind(GL20TU_PANTS             , rsurface.texture->pantstexture                      );
5249                 if (r_glsl_permutation->loc_Texture_Shirt           >= 0) R_Mesh_TexBind(GL20TU_SHIRT             , rsurface.texture->shirttexture                      );
5250                 if (r_glsl_permutation->loc_Texture_ReflectMask     >= 0) R_Mesh_TexBind(GL20TU_REFLECTMASK       , rsurface.texture->reflectmasktexture                );
5251                 if (r_glsl_permutation->loc_Texture_ReflectCube     >= 0) R_Mesh_TexBind(GL20TU_REFLECTCUBE       , rsurface.texture->reflectcubetexture ? rsurface.texture->reflectcubetexture : r_texture_whitecube);
5252                 if (r_glsl_permutation->loc_Texture_FogHeightTexture>= 0) R_Mesh_TexBind(GL20TU_FOGHEIGHTTEXTURE  , r_texture_fogheighttexture                          );
5253                 if (r_glsl_permutation->loc_Texture_FogMask         >= 0) R_Mesh_TexBind(GL20TU_FOGMASK           , r_texture_fogattenuation                            );
5254                 if (r_glsl_permutation->loc_Texture_Lightmap        >= 0) R_Mesh_TexBind(GL20TU_LIGHTMAP          , r_texture_white                                     );
5255                 if (r_glsl_permutation->loc_Texture_Deluxemap       >= 0) R_Mesh_TexBind(GL20TU_DELUXEMAP         , r_texture_blanknormalmap                            );
5256                 if (r_glsl_permutation->loc_Texture_Attenuation     >= 0) R_Mesh_TexBind(GL20TU_ATTENUATION       , r_shadow_attenuationgradienttexture                 );
5257                 if (r_glsl_permutation->loc_Texture_Refraction      >= 0) R_Mesh_TexBind(GL20TU_REFRACTION        , r_texture_white                                     );
5258                 if (r_glsl_permutation->loc_Texture_Reflection      >= 0) R_Mesh_TexBind(GL20TU_REFLECTION        , r_texture_white                                     );
5259                 if (r_glsl_permutation->loc_Texture_ScreenDepth     >= 0) R_Mesh_TexBind(GL20TU_SCREENDEPTH       , r_shadow_prepassgeometrydepthtexture                );
5260                 if (r_glsl_permutation->loc_Texture_ScreenNormalMap >= 0) R_Mesh_TexBind(GL20TU_SCREENNORMALMAP   , r_shadow_prepassgeometrynormalmaptexture            );
5261                 if (r_glsl_permutation->loc_Texture_ScreenDiffuse   >= 0) R_Mesh_TexBind(GL20TU_SCREENDIFFUSE     , r_shadow_prepasslightingdiffusetexture              );
5262                 if (r_glsl_permutation->loc_Texture_ScreenSpecular  >= 0) R_Mesh_TexBind(GL20TU_SCREENSPECULAR    , r_shadow_prepasslightingspeculartexture             );
5263                 if (rsurface.rtlight || (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW)))
5264                 {
5265                         if (r_glsl_permutation->loc_Texture_ShadowMap2D     >= 0) R_Mesh_TexBind(r_shadow_usingshadowmaportho ? GL20TU_SHADOWMAPORTHO2D : GL20TU_SHADOWMAP2D, r_shadow_shadowmap2dtexture                         );
5266                         if (r_glsl_permutation->loc_Texture_ShadowMapRect   >= 0) R_Mesh_TexBind(r_shadow_usingshadowmaportho ? GL20TU_SHADOWMAPORTHORECT : GL20TU_SHADOWMAPRECT, r_shadow_shadowmaprectangletexture                  );
5267                         if (rsurface.rtlight)
5268                         {
5269                                 if (r_glsl_permutation->loc_Texture_Cube            >= 0) R_Mesh_TexBind(GL20TU_CUBE              , rsurface.rtlight->currentcubemap                    );
5270                                 if (r_shadow_usingshadowmapcube)
5271                                         if (r_glsl_permutation->loc_Texture_ShadowMapCube   >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAPCUBE     , r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]);
5272                                 if (r_glsl_permutation->loc_Texture_CubeProjection  >= 0) R_Mesh_TexBind(GL20TU_CUBEPROJECTION    , r_shadow_shadowmapvsdcttexture                      );
5273                         }
5274                 }
5275                 CHECKGLERROR
5276                 break;
5277         case RENDERPATH_CGGL:
5278 #ifdef SUPPORTCG
5279                 R_SetupShader_SetPermutationCG(mode, permutation);
5280                 if (r_cg_permutation->fp_ModelToReflectCube) {Matrix4x4_ToArrayFloatGL(&rsurface.matrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->fp_ModelToReflectCube, m16f);}CHECKCGERROR
5281                 if (mode == SHADERMODE_LIGHTSOURCE)
5282                 {
5283                         if (r_cg_permutation->vp_ModelToLight) {Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelToLight, m16f);}CHECKCGERROR
5284                         if (r_cg_permutation->vp_LightPosition) cgGLSetParameter3f(r_cg_permutation->vp_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);CHECKCGERROR
5285                 }
5286                 else
5287                 {
5288                         if (mode == SHADERMODE_LIGHTDIRECTION)
5289                         {
5290                                 if (r_cg_permutation->vp_LightDir) cgGLSetParameter3f(r_cg_permutation->vp_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);CHECKCGERROR
5291                         }
5292                 }
5293                 if (r_cg_permutation->vp_TexMatrix) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currenttexmatrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_TexMatrix, m16f);}CHECKCGERROR
5294                 if (r_cg_permutation->vp_BackgroundTexMatrix) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currentbackgroundtexmatrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_BackgroundTexMatrix, m16f);}CHECKCGERROR
5295                 if (r_cg_permutation->vp_ShadowMapMatrix) {Matrix4x4_ToArrayFloatGL(&r_shadow_shadowmapmatrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_ShadowMapMatrix, m16f);}CHECKGLERROR
5296                 if (r_cg_permutation->vp_EyePosition) cgGLSetParameter3f(r_cg_permutation->vp_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);CHECKCGERROR
5297                 if (r_cg_permutation->vp_FogPlane) cgGLSetParameter4f(r_cg_permutation->vp_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]);CHECKCGERROR
5298                 CHECKGLERROR
5299
5300                 if (mode == SHADERMODE_LIGHTSOURCE)
5301                 {
5302                         if (r_cg_permutation->fp_LightPosition) cgGLSetParameter3f(r_cg_permutation->fp_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);CHECKCGERROR
5303                         if (r_cg_permutation->fp_LightColor) cgGLSetParameter3f(r_cg_permutation->fp_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);CHECKCGERROR
5304                         if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, colormod[0] * ambientscale, colormod[1] * ambientscale, colormod[2] * ambientscale);CHECKCGERROR
5305                         if (r_cg_permutation->fp_Color_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_Color_Diffuse, colormod[0] * diffusescale, colormod[1] * diffusescale, colormod[2] * diffusescale);CHECKCGERROR
5306                         if (r_cg_permutation->fp_Color_Specular) cgGLSetParameter3f(r_cg_permutation->fp_Color_Specular, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale);CHECKCGERROR
5307
5308                         // additive passes are only darkened by fog, not tinted
5309                         if (r_cg_permutation->fp_FogColor) cgGLSetParameter3f(r_cg_permutation->fp_FogColor, 0, 0, 0);CHECKCGERROR
5310                         if (r_cg_permutation->fp_SpecularPower) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));CHECKCGERROR
5311                 }
5312                 else
5313                 {
5314                         if (mode == SHADERMODE_FLATCOLOR)
5315                         {
5316                                 if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, colormod[0], colormod[1], colormod[2]);CHECKCGERROR
5317                         }
5318                         else if (mode == SHADERMODE_LIGHTDIRECTION)
5319                         {
5320                                 if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, (r_refdef.scene.ambient + rsurface.modellight_ambient[0] * r_refdef.lightmapintensity) * colormod[0], (r_refdef.scene.ambient + rsurface.modellight_ambient[1] * r_refdef.lightmapintensity) * colormod[1], (r_refdef.scene.ambient + rsurface.modellight_ambient[2] * r_refdef.lightmapintensity) * colormod[2]);CHECKCGERROR
5321                                 if (r_cg_permutation->fp_Color_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_Color_Diffuse, r_refdef.lightmapintensity * colormod[0], r_refdef.lightmapintensity * colormod[1], r_refdef.lightmapintensity * colormod[2]);CHECKCGERROR
5322                                 if (r_cg_permutation->fp_Color_Specular) cgGLSetParameter3f(r_cg_permutation->fp_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale);CHECKCGERROR
5323                                 if (r_cg_permutation->fp_DeferredMod_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_DeferredMod_Diffuse, colormod[0] * r_shadow_deferred_8bitrange.value, colormod[1] * r_shadow_deferred_8bitrange.value, colormod[2] * r_shadow_deferred_8bitrange.value);CHECKCGERROR
5324                                 if (r_cg_permutation->fp_DeferredMod_Specular) cgGLSetParameter3f(r_cg_permutation->fp_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value);CHECKCGERROR
5325                                 if (r_cg_permutation->fp_LightColor) cgGLSetParameter3f(r_cg_permutation->fp_LightColor, rsurface.modellight_diffuse[0], rsurface.modellight_diffuse[1], rsurface.modellight_diffuse[2]);CHECKCGERROR
5326                                 if (r_cg_permutation->fp_LightDir) cgGLSetParameter3f(r_cg_permutation->fp_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);CHECKCGERROR
5327                         }
5328                         else
5329                         {
5330                                 if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, r_refdef.scene.ambient * colormod[0], r_refdef.scene.ambient * colormod[1], r_refdef.scene.ambient * colormod[2]);CHECKCGERROR
5331                                 if (r_cg_permutation->fp_Color_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_Color_Diffuse, rsurface.texture->lightmapcolor[0], rsurface.texture->lightmapcolor[1], rsurface.texture->lightmapcolor[2]);CHECKCGERROR
5332                                 if (r_cg_permutation->fp_Color_Specular) cgGLSetParameter3f(r_cg_permutation->fp_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale);CHECKCGERROR
5333                                 if (r_cg_permutation->fp_DeferredMod_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_DeferredMod_Diffuse, colormod[0] * diffusescale * r_shadow_deferred_8bitrange.value, colormod[1] * diffusescale * r_shadow_deferred_8bitrange.value, colormod[2] * diffusescale * r_shadow_deferred_8bitrange.value);CHECKCGERROR
5334                                 if (r_cg_permutation->fp_DeferredMod_Specular) cgGLSetParameter3f(r_cg_permutation->fp_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value);CHECKCGERROR
5335                         }
5336                         // additive passes are only darkened by fog, not tinted
5337                         if (r_cg_permutation->fp_FogColor)
5338                         {
5339                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
5340                                         cgGLSetParameter3f(r_cg_permutation->fp_FogColor, 0, 0, 0);
5341                                 else
5342                                         cgGLSetParameter3f(r_cg_permutation->fp_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
5343                                 CHECKCGERROR
5344                         }
5345                         if (r_cg_permutation->fp_DistortScaleRefractReflect) cgGLSetParameter4f(r_cg_permutation->fp_DistortScaleRefractReflect, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor);CHECKCGERROR
5346                         if (r_cg_permutation->fp_ScreenScaleRefractReflect) cgGLSetParameter4f(r_cg_permutation->fp_ScreenScaleRefractReflect, r_waterstate.screenscale[0], r_waterstate.screenscale[1], r_waterstate.screenscale[0], r_waterstate.screenscale[1]);CHECKCGERROR
5347                         if (r_cg_permutation->fp_ScreenCenterRefractReflect) cgGLSetParameter4f(r_cg_permutation->fp_ScreenCenterRefractReflect, r_waterstate.screencenter[0], r_waterstate.screencenter[1], r_waterstate.screencenter[0], r_waterstate.screencenter[1]);CHECKCGERROR
5348                         if (r_cg_permutation->fp_RefractColor) cgGLSetParameter4fv(r_cg_permutation->fp_RefractColor, rsurface.texture->refractcolor4f);CHECKCGERROR
5349                         if (r_cg_permutation->fp_ReflectColor) cgGLSetParameter4fv(r_cg_permutation->fp_ReflectColor, rsurface.texture->reflectcolor4f);CHECKCGERROR
5350                         if (r_cg_permutation->fp_ReflectFactor) cgGLSetParameter1f(r_cg_permutation->fp_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);CHECKCGERROR
5351                         if (r_cg_permutation->fp_ReflectOffset) cgGLSetParameter1f(r_cg_permutation->fp_ReflectOffset, rsurface.texture->reflectmin);CHECKCGERROR
5352                         if (r_cg_permutation->fp_SpecularPower) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));CHECKCGERROR
5353                 }
5354                 if (r_cg_permutation->fp_ShadowMap_TextureScale) cgGLSetParameter2f(r_cg_permutation->fp_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);CHECKCGERROR
5355                 if (r_cg_permutation->fp_ShadowMap_Parameters) cgGLSetParameter4f(r_cg_permutation->fp_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);CHECKCGERROR
5356                 if (r_cg_permutation->fp_Color_Glow) cgGLSetParameter3f(r_cg_permutation->fp_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]);CHECKCGERROR
5357                 if (r_cg_permutation->fp_Alpha) cgGLSetParameter1f(r_cg_permutation->fp_Alpha, rsurface.texture->lightmapcolor[3]);CHECKCGERROR
5358                 if (r_cg_permutation->fp_EyePosition) cgGLSetParameter3f(r_cg_permutation->fp_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);CHECKCGERROR
5359                 if (r_cg_permutation->fp_Color_Pants)
5360                 {
5361                         if (rsurface.texture->pantstexture)
5362                                 cgGLSetParameter3f(r_cg_permutation->fp_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
5363                         else
5364                                 cgGLSetParameter3f(r_cg_permutation->fp_Color_Pants, 0, 0, 0);
5365                         CHECKCGERROR
5366                 }
5367                 if (r_cg_permutation->fp_Color_Shirt)
5368                 {
5369                         if (rsurface.texture->shirttexture)
5370                                 cgGLSetParameter3f(r_cg_permutation->fp_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
5371                         else
5372                                 cgGLSetParameter3f(r_cg_permutation->fp_Color_Shirt, 0, 0, 0);
5373                         CHECKCGERROR
5374                 }
5375                 if (r_cg_permutation->fp_FogPlane) cgGLSetParameter4f(r_cg_permutation->fp_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]);CHECKCGERROR
5376                 if (r_cg_permutation->fp_FogPlaneViewDist) cgGLSetParameter1f(r_cg_permutation->fp_FogPlaneViewDist, rsurface.fogplaneviewdist);CHECKCGERROR
5377                 if (r_cg_permutation->fp_FogRangeRecip) cgGLSetParameter1f(r_cg_permutation->fp_FogRangeRecip, rsurface.fograngerecip);CHECKCGERROR
5378                 if (r_cg_permutation->fp_FogHeightFade) cgGLSetParameter1f(r_cg_permutation->fp_FogHeightFade, rsurface.fogheightfade);CHECKCGERROR
5379                 if (r_cg_permutation->fp_OffsetMapping_Scale) cgGLSetParameter1f(r_cg_permutation->fp_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);CHECKCGERROR
5380                 if (r_cg_permutation->fp_ScreenToDepth) cgGLSetParameter2f(r_cg_permutation->fp_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);CHECKCGERROR
5381                 if (r_cg_permutation->fp_PixelToScreenTexCoord) cgGLSetParameter2f(r_cg_permutation->fp_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);CHECKCGERROR
5382
5383         //      if (r_cg_permutation->fp_Texture_First          ) CG_BindTexture(r_cg_permutation->fp_Texture_First          , r_texture_white                                     );CHECKCGERROR
5384         //      if (r_cg_permutation->fp_Texture_Second         ) CG_BindTexture(r_cg_permutation->fp_Texture_Second         , r_texture_white                                     );CHECKCGERROR
5385         //      if (r_cg_permutation->fp_Texture_GammaRamps     ) CG_BindTexture(r_cg_permutation->fp_Texture_GammaRamps     , r_texture_gammaramps                                );CHECKCGERROR
5386                 if (r_cg_permutation->fp_Texture_Normal         ) CG_BindTexture(r_cg_permutation->fp_Texture_Normal         , rsurface.texture->nmaptexture                       );CHECKCGERROR
5387                 if (r_cg_permutation->fp_Texture_Color          ) CG_BindTexture(r_cg_permutation->fp_Texture_Color          , rsurface.texture->basetexture                       );CHECKCGERROR
5388                 if (r_cg_permutation->fp_Texture_Gloss          ) CG_BindTexture(r_cg_permutation->fp_Texture_Gloss          , rsurface.texture->glosstexture                      );CHECKCGERROR
5389                 if (r_cg_permutation->fp_Texture_Glow           ) CG_BindTexture(r_cg_permutation->fp_Texture_Glow           , rsurface.texture->glowtexture                       );CHECKCGERROR
5390                 if (r_cg_permutation->fp_Texture_SecondaryNormal) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryNormal, rsurface.texture->backgroundnmaptexture             );CHECKCGERROR
5391                 if (r_cg_permutation->fp_Texture_SecondaryColor ) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryColor , rsurface.texture->backgroundbasetexture             );CHECKCGERROR
5392                 if (r_cg_permutation->fp_Texture_SecondaryGloss ) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryGloss , rsurface.texture->backgroundglosstexture            );CHECKCGERROR
5393                 if (r_cg_permutation->fp_Texture_SecondaryGlow  ) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryGlow  , rsurface.texture->backgroundglowtexture             );CHECKCGERROR
5394                 if (r_cg_permutation->fp_Texture_Pants          ) CG_BindTexture(r_cg_permutation->fp_Texture_Pants          , rsurface.texture->pantstexture                      );CHECKCGERROR
5395                 if (r_cg_permutation->fp_Texture_Shirt          ) CG_BindTexture(r_cg_permutation->fp_Texture_Shirt          , rsurface.texture->shirttexture                      );CHECKCGERROR
5396                 if (r_cg_permutation->fp_Texture_ReflectMask    ) CG_BindTexture(r_cg_permutation->fp_Texture_ReflectMask    , rsurface.texture->reflectmasktexture                );CHECKCGERROR
5397                 if (r_cg_permutation->fp_Texture_ReflectCube    ) CG_BindTexture(r_cg_permutation->fp_Texture_ReflectCube    , rsurface.texture->reflectcubetexture ? rsurface.texture->reflectcubetexture : r_texture_whitecube);CHECKCGERROR
5398                 if (r_cg_permutation->fp_Texture_FogHeightTexture) CG_BindTexture(r_cg_permutation->fp_Texture_FogHeightTexture, r_texture_fogheighttexture                         );CHECKCGERROR
5399                 if (r_cg_permutation->fp_Texture_FogMask        ) CG_BindTexture(r_cg_permutation->fp_Texture_FogMask        , r_texture_fogattenuation                            );CHECKCGERROR
5400                 if (r_cg_permutation->fp_Texture_Lightmap       ) CG_BindTexture(r_cg_permutation->fp_Texture_Lightmap       , r_texture_white                                     );CHECKCGERROR
5401                 if (r_cg_permutation->fp_Texture_Deluxemap      ) CG_BindTexture(r_cg_permutation->fp_Texture_Deluxemap      , r_texture_blanknormalmap                            );CHECKCGERROR
5402                 if (r_cg_permutation->fp_Texture_Attenuation    ) CG_BindTexture(r_cg_permutation->fp_Texture_Attenuation    , r_shadow_attenuationgradienttexture                 );CHECKCGERROR
5403                 if (r_cg_permutation->fp_Texture_Refraction     ) CG_BindTexture(r_cg_permutation->fp_Texture_Refraction     , r_texture_white                                     );CHECKCGERROR
5404                 if (r_cg_permutation->fp_Texture_Reflection     ) CG_BindTexture(r_cg_permutation->fp_Texture_Reflection     , r_texture_white                                     );CHECKCGERROR
5405                 if (r_cg_permutation->fp_Texture_ScreenDepth    ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDepth    , r_shadow_prepassgeometrydepthtexture                );CHECKCGERROR
5406                 if (r_cg_permutation->fp_Texture_ScreenNormalMap) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenNormalMap, r_shadow_prepassgeometrynormalmaptexture            );CHECKCGERROR
5407                 if (r_cg_permutation->fp_Texture_ScreenDiffuse  ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDiffuse  , r_shadow_prepasslightingdiffusetexture              );CHECKCGERROR
5408                 if (r_cg_permutation->fp_Texture_ScreenSpecular ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenSpecular , r_shadow_prepasslightingspeculartexture             );CHECKCGERROR
5409                 if (rsurface.rtlight || (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW)))
5410                 {
5411                         if (r_cg_permutation->fp_Texture_ShadowMap2D    ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMap2D    , r_shadow_shadowmap2dtexture                         );CHECKCGERROR
5412                         if (r_cg_permutation->fp_Texture_ShadowMapRect  ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapRect  , r_shadow_shadowmaprectangletexture                  );CHECKCGERROR
5413                         if (rsurface.rtlight)
5414                         {
5415                                 if (r_cg_permutation->fp_Texture_Cube           ) CG_BindTexture(r_cg_permutation->fp_Texture_Cube           , rsurface.rtlight->currentcubemap                    );CHECKCGERROR
5416                                 if (r_shadow_usingshadowmapcube)
5417                                         if (r_cg_permutation->fp_Texture_ShadowMapCube  ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapCube  , r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]);CHECKCGERROR
5418                                 if (r_cg_permutation->fp_Texture_CubeProjection ) CG_BindTexture(r_cg_permutation->fp_Texture_CubeProjection , r_shadow_shadowmapvsdcttexture                      );CHECKCGERROR
5419                         }
5420                 }
5421
5422                 CHECKGLERROR
5423 #endif
5424                 break;
5425         case RENDERPATH_GL13:
5426         case RENDERPATH_GL11:
5427                 break;
5428         }
5429 }
5430
5431 void R_SetupShader_DeferredLight(const rtlight_t *rtlight)
5432 {
5433         // select a permutation of the lighting shader appropriate to this
5434         // combination of texture, entity, light source, and fogging, only use the
5435         // minimum features necessary to avoid wasting rendering time in the
5436         // fragment shader on features that are not being used
5437         unsigned int permutation = 0;
5438         unsigned int mode = 0;
5439         const float *lightcolorbase = rtlight->currentcolor;
5440         float ambientscale = rtlight->ambientscale;
5441         float diffusescale = rtlight->diffusescale;
5442         float specularscale = rtlight->specularscale;
5443         // this is the location of the light in view space
5444         vec3_t viewlightorigin;
5445         // this transforms from view space (camera) to light space (cubemap)
5446         matrix4x4_t viewtolight;
5447         matrix4x4_t lighttoview;
5448         float viewtolight16f[16];
5449         float range = 1.0f / r_shadow_deferred_8bitrange.value;
5450         // light source
5451         mode = SHADERMODE_DEFERREDLIGHTSOURCE;
5452         if (rtlight->currentcubemap != r_texture_whitecube)
5453                 permutation |= SHADERPERMUTATION_CUBEFILTER;
5454         if (diffusescale > 0)
5455                 permutation |= SHADERPERMUTATION_DIFFUSE;
5456         if (specularscale > 0)
5457         {
5458                 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
5459                 if (r_shadow_glossexact.integer)
5460                         permutation |= SHADERPERMUTATION_EXACTSPECULARMATH;
5461         }
5462         if (r_shadow_usingshadowmaprect || r_shadow_usingshadowmap2d || r_shadow_usingshadowmapcube)
5463         {
5464                 if (r_shadow_usingshadowmaprect)
5465                         permutation |= SHADERPERMUTATION_SHADOWMAPRECT;
5466                 if (r_shadow_usingshadowmap2d)
5467                         permutation |= SHADERPERMUTATION_SHADOWMAP2D;
5468                 if (r_shadow_usingshadowmapcube)
5469                         permutation |= SHADERPERMUTATION_SHADOWMAPCUBE;
5470                 else if(r_shadow_shadowmapvsdct)
5471                         permutation |= SHADERPERMUTATION_SHADOWMAPVSDCT;
5472
5473                 if (r_shadow_shadowmapsampler)
5474                         permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
5475                 if (r_shadow_shadowmappcf > 1)
5476                         permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
5477                 else if (r_shadow_shadowmappcf)
5478                         permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
5479         }
5480         Matrix4x4_Transform(&r_refdef.view.viewport.viewmatrix, rtlight->shadoworigin, viewlightorigin);
5481         Matrix4x4_Concat(&lighttoview, &r_refdef.view.viewport.viewmatrix, &rtlight->matrix_lighttoworld);
5482         Matrix4x4_Invert_Simple(&viewtolight, &lighttoview);
5483         Matrix4x4_ToArrayFloatGL(&viewtolight, viewtolight16f);
5484         switch(vid.renderpath)
5485         {
5486         case RENDERPATH_GL20:
5487                 R_SetupShader_SetPermutationGLSL(mode, permutation);
5488                 if (r_glsl_permutation->loc_LightPosition             >= 0) qglUniform3fARB(       r_glsl_permutation->loc_LightPosition            , viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]);
5489                 if (r_glsl_permutation->loc_ViewToLight               >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ViewToLight              , 1, false, viewtolight16f);
5490                 if (r_glsl_permutation->loc_DeferredColor_Ambient     >= 0) qglUniform3fARB(       r_glsl_permutation->loc_DeferredColor_Ambient    , lightcolorbase[0] * ambientscale  * range, lightcolorbase[1] * ambientscale  * range, lightcolorbase[2] * ambientscale  * range);
5491                 if (r_glsl_permutation->loc_DeferredColor_Diffuse     >= 0) qglUniform3fARB(       r_glsl_permutation->loc_DeferredColor_Diffuse    , lightcolorbase[0] * diffusescale  * range, lightcolorbase[1] * diffusescale  * range, lightcolorbase[2] * diffusescale  * range);
5492                 if (r_glsl_permutation->loc_DeferredColor_Specular    >= 0) qglUniform3fARB(       r_glsl_permutation->loc_DeferredColor_Specular   , lightcolorbase[0] * specularscale * range, lightcolorbase[1] * specularscale * range, lightcolorbase[2] * specularscale * range);
5493                 if (r_glsl_permutation->loc_ShadowMap_TextureScale    >= 0) qglUniform2fARB(       r_glsl_permutation->loc_ShadowMap_TextureScale   , r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);
5494                 if (r_glsl_permutation->loc_ShadowMap_Parameters      >= 0) qglUniform4fARB(       r_glsl_permutation->loc_ShadowMap_Parameters     , r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);
5495                 if (r_glsl_permutation->loc_SpecularPower             >= 0) qglUniform1fARB(       r_glsl_permutation->loc_SpecularPower            , (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));
5496                 if (r_glsl_permutation->loc_ScreenToDepth             >= 0) qglUniform2fARB(       r_glsl_permutation->loc_ScreenToDepth            , r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);
5497                 if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
5498
5499                 if (r_glsl_permutation->loc_Texture_Attenuation       >= 0) R_Mesh_TexBind(GL20TU_ATTENUATION        , r_shadow_attenuationgradienttexture                 );
5500                 if (r_glsl_permutation->loc_Texture_ScreenDepth       >= 0) R_Mesh_TexBind(GL20TU_SCREENDEPTH        , r_shadow_prepassgeometrydepthtexture                );
5501                 if (r_glsl_permutation->loc_Texture_ScreenNormalMap   >= 0) R_Mesh_TexBind(GL20TU_SCREENNORMALMAP    , r_shadow_prepassgeometrynormalmaptexture            );
5502                 if (r_glsl_permutation->loc_Texture_Cube              >= 0) R_Mesh_TexBind(GL20TU_CUBE               , rsurface.rtlight->currentcubemap                    );
5503                 if (r_glsl_permutation->loc_Texture_ShadowMapRect     >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAPRECT      , r_shadow_shadowmaprectangletexture                  );
5504                 if (r_shadow_usingshadowmapcube)
5505                         if (r_glsl_permutation->loc_Texture_ShadowMapCube     >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAPCUBE      , r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]);
5506                 if (r_glsl_permutation->loc_Texture_ShadowMap2D       >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAP2D        , r_shadow_shadowmap2dtexture                         );
5507                 if (r_glsl_permutation->loc_Texture_CubeProjection    >= 0) R_Mesh_TexBind(GL20TU_CUBEPROJECTION     , r_shadow_shadowmapvsdcttexture                      );
5508                 break;
5509         case RENDERPATH_CGGL:
5510 #ifdef SUPPORTCG
5511                 R_SetupShader_SetPermutationCG(mode, permutation);
5512                 if (r_cg_permutation->fp_LightPosition            ) cgGLSetParameter3f(r_cg_permutation->fp_LightPosition, viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]);CHECKCGERROR
5513                 if (r_cg_permutation->fp_ViewToLight              ) cgGLSetMatrixParameterfc(r_cg_permutation->fp_ViewToLight, viewtolight16f);CHECKCGERROR
5514                 if (r_cg_permutation->fp_DeferredColor_Ambient    ) cgGLSetParameter3f(r_cg_permutation->fp_DeferredColor_Ambient , lightcolorbase[0] * ambientscale  * range, lightcolorbase[1] * ambientscale  * range, lightcolorbase[2] * ambientscale  * range);CHECKCGERROR
5515                 if (r_cg_permutation->fp_DeferredColor_Diffuse    ) cgGLSetParameter3f(r_cg_permutation->fp_DeferredColor_Diffuse , lightcolorbase[0] * diffusescale  * range, lightcolorbase[1] * diffusescale  * range, lightcolorbase[2] * diffusescale  * range);CHECKCGERROR
5516                 if (r_cg_permutation->fp_DeferredColor_Specular   ) cgGLSetParameter3f(r_cg_permutation->fp_DeferredColor_Specular, lightcolorbase[0] * specularscale * range, lightcolorbase[1] * specularscale * range, lightcolorbase[2] * specularscale * range);CHECKCGERROR
5517                 if (r_cg_permutation->fp_ShadowMap_TextureScale   ) cgGLSetParameter2f(r_cg_permutation->fp_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);CHECKCGERROR
5518                 if (r_cg_permutation->fp_ShadowMap_Parameters     ) cgGLSetParameter4f(r_cg_permutation->fp_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);CHECKCGERROR
5519                 if (r_cg_permutation->fp_SpecularPower            ) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));CHECKCGERROR
5520                 if (r_cg_permutation->fp_ScreenToDepth            ) cgGLSetParameter2f(r_cg_permutation->fp_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);CHECKCGERROR
5521                 if (r_cg_permutation->fp_PixelToScreenTexCoord    ) cgGLSetParameter2f(r_cg_permutation->fp_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);CHECKCGERROR
5522
5523                 if (r_cg_permutation->fp_Texture_Attenuation      ) CG_BindTexture(r_cg_permutation->fp_Texture_Attenuation    , r_shadow_attenuationgradienttexture                 );CHECKCGERROR
5524                 if (r_cg_permutation->fp_Texture_ScreenDepth      ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDepth    , r_shadow_prepassgeometrydepthtexture                );CHECKCGERROR
5525                 if (r_cg_permutation->fp_Texture_ScreenNormalMap  ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenNormalMap, r_shadow_prepassgeometrynormalmaptexture            );CHECKCGERROR
5526                 if (r_cg_permutation->fp_Texture_Cube             ) CG_BindTexture(r_cg_permutation->fp_Texture_Cube           , rsurface.rtlight->currentcubemap                    );CHECKCGERROR
5527                 if (r_cg_permutation->fp_Texture_ShadowMapRect    ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapRect  , r_shadow_shadowmaprectangletexture                  );CHECKCGERROR
5528                 if (r_shadow_usingshadowmapcube)
5529                         if (r_cg_permutation->fp_Texture_ShadowMapCube    ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapCube  , r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]);CHECKCGERROR
5530                 if (r_cg_permutation->fp_Texture_ShadowMap2D      ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMap2D    , r_shadow_shadowmap2dtexture                         );CHECKCGERROR
5531                 if (r_cg_permutation->fp_Texture_CubeProjection   ) CG_BindTexture(r_cg_permutation->fp_Texture_CubeProjection , r_shadow_shadowmapvsdcttexture                      );CHECKCGERROR
5532 #endif
5533                 break;
5534         case RENDERPATH_GL13:
5535         case RENDERPATH_GL11:
5536                 break;
5537         }
5538 }
5539
5540 #define SKINFRAME_HASH 1024
5541
5542 typedef struct
5543 {
5544         int loadsequence; // incremented each level change
5545         memexpandablearray_t array;
5546         skinframe_t *hash[SKINFRAME_HASH];
5547 }
5548 r_skinframe_t;
5549 r_skinframe_t r_skinframe;
5550
5551 void R_SkinFrame_PrepareForPurge(void)
5552 {
5553         r_skinframe.loadsequence++;
5554         // wrap it without hitting zero
5555         if (r_skinframe.loadsequence >= 200)
5556                 r_skinframe.loadsequence = 1;
5557 }
5558
5559 void R_SkinFrame_MarkUsed(skinframe_t *skinframe)
5560 {
5561         if (!skinframe)
5562                 return;
5563         // mark the skinframe as used for the purging code
5564         skinframe->loadsequence = r_skinframe.loadsequence;
5565 }
5566
5567 void R_SkinFrame_Purge(void)
5568 {
5569         int i;
5570         skinframe_t *s;
5571         for (i = 0;i < SKINFRAME_HASH;i++)
5572         {
5573                 for (s = r_skinframe.hash[i];s;s = s->next)
5574                 {
5575                         if (s->loadsequence && s->loadsequence != r_skinframe.loadsequence)
5576                         {
5577                                 if (s->merged == s->base)
5578                                         s->merged = NULL;
5579                                 // FIXME: maybe pass a pointer to the pointer to R_PurgeTexture and reset it to NULL inside? [11/29/2007 Black]
5580                                 R_PurgeTexture(s->stain );s->stain  = NULL;
5581                                 R_PurgeTexture(s->merged);s->merged = NULL;
5582                                 R_PurgeTexture(s->base  );s->base   = NULL;
5583                                 R_PurgeTexture(s->pants );s->pants  = NULL;
5584                                 R_PurgeTexture(s->shirt );s->shirt  = NULL;
5585                                 R_PurgeTexture(s->nmap  );s->nmap   = NULL;
5586                                 R_PurgeTexture(s->gloss );s->gloss  = NULL;
5587                                 R_PurgeTexture(s->glow  );s->glow   = NULL;
5588                                 R_PurgeTexture(s->fog   );s->fog    = NULL;
5589                                 R_PurgeTexture(s->reflect);s->reflect = NULL;
5590                                 s->loadsequence = 0;
5591                         }
5592                 }
5593         }
5594 }
5595
5596 skinframe_t *R_SkinFrame_FindNextByName( skinframe_t *last, const char *name ) {
5597         skinframe_t *item;
5598         char basename[MAX_QPATH];
5599
5600         Image_StripImageExtension(name, basename, sizeof(basename));
5601
5602         if( last == NULL ) {
5603                 int hashindex;
5604                 hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
5605                 item = r_skinframe.hash[hashindex];
5606         } else {
5607                 item = last->next;
5608         }
5609
5610         // linearly search through the hash bucket
5611         for( ; item ; item = item->next ) {
5612                 if( !strcmp( item->basename, basename ) ) {
5613                         return item;
5614                 }
5615         }
5616         return NULL;
5617 }
5618
5619 skinframe_t *R_SkinFrame_Find(const char *name, int textureflags, int comparewidth, int compareheight, int comparecrc, qboolean add)
5620 {
5621         skinframe_t *item;
5622         int hashindex;
5623         char basename[MAX_QPATH];
5624
5625         Image_StripImageExtension(name, basename, sizeof(basename));
5626
5627         hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
5628         for (item = r_skinframe.hash[hashindex];item;item = item->next)
5629                 if (!strcmp(item->basename, basename) && item->textureflags == textureflags && item->comparewidth == comparewidth && item->compareheight == compareheight && item->comparecrc == comparecrc)
5630                         break;
5631
5632         if (!item) {
5633                 rtexture_t *dyntexture;
5634                 // check whether its a dynamic texture
5635                 dyntexture = CL_GetDynTexture( basename );
5636                 if (!add && !dyntexture)
5637                         return NULL;
5638                 item = (skinframe_t *)Mem_ExpandableArray_AllocRecord(&r_skinframe.array);
5639                 memset(item, 0, sizeof(*item));
5640                 strlcpy(item->basename, basename, sizeof(item->basename));
5641                 item->base = dyntexture; // either NULL or dyntexture handle
5642                 item->textureflags = textureflags;
5643                 item->comparewidth = comparewidth;
5644                 item->compareheight = compareheight;
5645                 item->comparecrc = comparecrc;
5646                 item->next = r_skinframe.hash[hashindex];
5647                 r_skinframe.hash[hashindex] = item;
5648         }
5649         else if( item->base == NULL )
5650         {
5651                 rtexture_t *dyntexture;
5652                 // check whether its a dynamic texture
5653                 // this only needs to be done because Purge doesnt delete skinframes - only sets the texture pointers to NULL and we need to restore it before returing.. [11/29/2007 Black]
5654                 dyntexture = CL_GetDynTexture( basename );
5655                 item->base = dyntexture; // either NULL or dyntexture handle
5656         }
5657
5658         R_SkinFrame_MarkUsed(item);
5659         return item;
5660 }
5661
5662 #define R_SKINFRAME_LOAD_AVERAGE_COLORS(cnt, getpixel) \
5663         { \
5664                 unsigned long long avgcolor[5], wsum; \
5665                 int pix, comp, w; \
5666                 avgcolor[0] = 0; \
5667                 avgcolor[1] = 0; \
5668                 avgcolor[2] = 0; \
5669                 avgcolor[3] = 0; \
5670                 avgcolor[4] = 0; \
5671                 wsum = 0; \
5672                 for(pix = 0; pix < cnt; ++pix) \
5673                 { \
5674                         w = 0; \
5675                         for(comp = 0; comp < 3; ++comp) \
5676                                 w += getpixel; \
5677                         if(w) /* ignore perfectly black pixels because that is better for model skins */ \
5678                         { \
5679                                 ++wsum; \
5680                                 /* comp = 3; -- not needed, comp is always 3 when we get here */ \
5681                                 w = getpixel; \
5682                                 for(comp = 0; comp < 3; ++comp) \
5683                                         avgcolor[comp] += getpixel * w; \
5684                                 avgcolor[3] += w; \
5685                         } \
5686                         /* comp = 3; -- not needed, comp is always 3 when we get here */ \
5687                         avgcolor[4] += getpixel; \
5688                 } \
5689                 if(avgcolor[3] == 0) /* no pixels seen? even worse */ \
5690                         avgcolor[3] = 1; \
5691                 skinframe->avgcolor[0] = avgcolor[2] / (255.0 * avgcolor[3]); \
5692                 skinframe->avgcolor[1] = avgcolor[1] / (255.0 * avgcolor[3]); \
5693                 skinframe->avgcolor[2] = avgcolor[0] / (255.0 * avgcolor[3]); \
5694                 skinframe->avgcolor[3] = avgcolor[4] / (255.0 * cnt); \
5695         }
5696
5697 extern cvar_t gl_picmip;
5698 skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboolean complain)
5699 {
5700         int j;
5701         unsigned char *pixels;
5702         unsigned char *bumppixels;
5703         unsigned char *basepixels = NULL;
5704         int basepixels_width = 0;
5705         int basepixels_height = 0;
5706         skinframe_t *skinframe;
5707         rtexture_t *ddsbase = NULL;
5708         qboolean ddshasalpha = false;
5709         float ddsavgcolor[4];
5710         char basename[MAX_QPATH];
5711         int miplevel = R_PicmipForFlags(textureflags);
5712         int savemiplevel = miplevel;
5713         int mymiplevel;
5714
5715         if (cls.state == ca_dedicated)
5716                 return NULL;
5717
5718         // return an existing skinframe if already loaded
5719         // if loading of the first image fails, don't make a new skinframe as it
5720         // would cause all future lookups of this to be missing
5721         skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
5722         if (skinframe && skinframe->base)
5723                 return skinframe;
5724
5725         Image_StripImageExtension(name, basename, sizeof(basename));
5726
5727         // check for DDS texture file first
5728         if (!r_loaddds || !(ddsbase = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s.dds", basename), textureflags, &ddshasalpha, ddsavgcolor, miplevel)))
5729         {
5730                 basepixels = loadimagepixelsbgra(name, complain, true, r_texture_convertsRGB_skin.integer, &miplevel);
5731                 if (basepixels == NULL)
5732                         return NULL;
5733         }
5734
5735         // FIXME handle miplevel
5736
5737         if (developer_loading.integer)
5738                 Con_Printf("loading skin \"%s\"\n", name);
5739
5740         // we've got some pixels to store, so really allocate this new texture now
5741         if (!skinframe)
5742                 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, true);
5743         skinframe->stain = NULL;
5744         skinframe->merged = NULL;
5745         skinframe->base = NULL;
5746         skinframe->pants = NULL;
5747         skinframe->shirt = NULL;
5748         skinframe->nmap = NULL;
5749         skinframe->gloss = NULL;
5750         skinframe->glow = NULL;
5751         skinframe->fog = NULL;
5752         skinframe->reflect = NULL;
5753         skinframe->hasalpha = false;
5754
5755         if (ddsbase)
5756         {
5757                 skinframe->base = ddsbase;
5758                 skinframe->hasalpha = ddshasalpha;
5759                 VectorCopy(ddsavgcolor, skinframe->avgcolor);
5760                 if (r_loadfog && skinframe->hasalpha)
5761                         skinframe->fog = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_mask.dds", skinframe->basename), textureflags | TEXF_ALPHA, NULL, NULL, miplevel);
5762                 //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]);
5763         }
5764         else
5765         {
5766                 basepixels_width = image_width;
5767                 basepixels_height = image_height;
5768                 skinframe->base = R_LoadTexture2D (r_main_texturepool, skinframe->basename, basepixels_width, basepixels_height, basepixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), miplevel, NULL);
5769                 if (textureflags & TEXF_ALPHA)
5770                 {
5771                         for (j = 3;j < basepixels_width * basepixels_height * 4;j += 4)
5772                         {
5773                                 if (basepixels[j] < 255)
5774                                 {
5775                                         skinframe->hasalpha = true;
5776                                         break;
5777                                 }
5778                         }
5779                         if (r_loadfog && skinframe->hasalpha)
5780                         {
5781                                 // has transparent pixels
5782                                 pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
5783                                 for (j = 0;j < image_width * image_height * 4;j += 4)
5784                                 {
5785                                         pixels[j+0] = 255;
5786                                         pixels[j+1] = 255;
5787                                         pixels[j+2] = 255;
5788                                         pixels[j+3] = basepixels[j+3];
5789                                 }
5790                                 skinframe->fog = R_LoadTexture2D (r_main_texturepool, va("%s_mask", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), miplevel, NULL);
5791                                 Mem_Free(pixels);
5792                         }
5793                 }
5794                 R_SKINFRAME_LOAD_AVERAGE_COLORS(basepixels_width * basepixels_height, basepixels[4 * pix + comp]);
5795                 //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]);
5796                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->base)
5797                         R_SaveTextureDDSFile(skinframe->base, va("dds/%s.dds", skinframe->basename), true, skinframe->hasalpha);
5798                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->fog)
5799                         R_SaveTextureDDSFile(skinframe->fog, va("dds/%s_mask.dds", skinframe->basename), true, true);
5800         }
5801
5802         if (r_loaddds)
5803         {
5804                 mymiplevel = savemiplevel;
5805                 if (r_loadnormalmap)
5806                         skinframe->nmap = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_norm.dds", skinframe->basename), (TEXF_ALPHA | textureflags) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP), NULL, NULL, mymiplevel);
5807                 skinframe->glow = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_glow.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel);
5808                 if (r_loadgloss)
5809                         skinframe->gloss = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_gloss.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel);
5810                 skinframe->pants = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_pants.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel);
5811                 skinframe->shirt = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_shirt.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel);
5812                 skinframe->reflect = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_reflect.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel);
5813         }
5814
5815         // _norm is the name used by tenebrae and has been adopted as standard
5816         if (r_loadnormalmap && skinframe->nmap == NULL)
5817         {
5818                 mymiplevel = savemiplevel;
5819                 if ((pixels = loadimagepixelsbgra(va("%s_norm", skinframe->basename), false, false, false, &mymiplevel)) != NULL)
5820                 {
5821                         skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | textureflags) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP) & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
5822                         Mem_Free(pixels);
5823                         pixels = NULL;
5824                 }
5825                 else if (r_shadow_bumpscale_bumpmap.value > 0 && (bumppixels = loadimagepixelsbgra(va("%s_bump", skinframe->basename), false, false, false, &mymiplevel)) != NULL)
5826                 {
5827                         pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
5828                         Image_HeightmapToNormalmap_BGRA(bumppixels, pixels, image_width, image_height, false, r_shadow_bumpscale_bumpmap.value);
5829                         skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | textureflags) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP) & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
5830                         Mem_Free(pixels);
5831                         Mem_Free(bumppixels);
5832                 }
5833                 else if (r_shadow_bumpscale_basetexture.value > 0)
5834                 {
5835                         pixels = (unsigned char *)Mem_Alloc(tempmempool, basepixels_width * basepixels_height * 4);
5836                         Image_HeightmapToNormalmap_BGRA(basepixels, pixels, basepixels_width, basepixels_height, false, r_shadow_bumpscale_basetexture.value);
5837                         skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), basepixels_width, basepixels_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | textureflags) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP) & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
5838                         Mem_Free(pixels);
5839                 }
5840                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->nmap)
5841                         R_SaveTextureDDSFile(skinframe->nmap, va("dds/%s_norm.dds", skinframe->basename), true, true);
5842         }
5843
5844         // _luma is supported only for tenebrae compatibility
5845         // _glow is the preferred name
5846         mymiplevel = savemiplevel;
5847         if (skinframe->glow == NULL && ((pixels = loadimagepixelsbgra(va("%s_glow",  skinframe->basename), false, false, r_texture_convertsRGB_skin.integer, &mymiplevel)) || (pixels = loadimagepixelsbgra(va("%s_luma", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer, &mymiplevel))))
5848         {
5849                 skinframe->glow = R_LoadTexture2D (r_main_texturepool, va("%s_glow", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_glow.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
5850                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->glow)
5851                         R_SaveTextureDDSFile(skinframe->glow, va("dds/%s_glow.dds", skinframe->basename), true, true);
5852                 Mem_Free(pixels);pixels = NULL;
5853         }
5854
5855         mymiplevel = savemiplevel;
5856         if (skinframe->gloss == NULL && r_loadgloss && (pixels = loadimagepixelsbgra(va("%s_gloss", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer, &mymiplevel)))
5857         {
5858                 skinframe->gloss = R_LoadTexture2D (r_main_texturepool, va("%s_gloss", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_gloss.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
5859                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->gloss)
5860                         R_SaveTextureDDSFile(skinframe->gloss, va("dds/%s_gloss.dds", skinframe->basename), true, true);
5861                 Mem_Free(pixels);
5862                 pixels = NULL;
5863         }
5864
5865         mymiplevel = savemiplevel;
5866         if (skinframe->pants == NULL && (pixels = loadimagepixelsbgra(va("%s_pants", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer, &mymiplevel)))
5867         {
5868                 skinframe->pants = R_LoadTexture2D (r_main_texturepool, va("%s_pants", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
5869                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->pants)
5870                         R_SaveTextureDDSFile(skinframe->pants, va("dds/%s_pants.dds", skinframe->basename), true, false);
5871                 Mem_Free(pixels);
5872                 pixels = NULL;
5873         }
5874
5875         mymiplevel = savemiplevel;
5876         if (skinframe->shirt == NULL && (pixels = loadimagepixelsbgra(va("%s_shirt", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer, &mymiplevel)))
5877         {
5878                 skinframe->shirt = R_LoadTexture2D (r_main_texturepool, va("%s_shirt", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
5879                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->shirt)
5880                         R_SaveTextureDDSFile(skinframe->shirt, va("dds/%s_shirt.dds", skinframe->basename), true, false);
5881                 Mem_Free(pixels);
5882                 pixels = NULL;
5883         }
5884
5885         mymiplevel = savemiplevel;
5886         if (skinframe->reflect == NULL && (pixels = loadimagepixelsbgra(va("%s_reflect", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer, &mymiplevel)))
5887         {
5888                 skinframe->reflect = R_LoadTexture2D (r_main_texturepool, va("%s_reflect", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_reflectmask.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
5889                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->reflect)
5890                         R_SaveTextureDDSFile(skinframe->reflect, va("dds/%s_reflect.dds", skinframe->basename), true, true);
5891                 Mem_Free(pixels);
5892                 pixels = NULL;
5893         }
5894
5895         if (basepixels)
5896                 Mem_Free(basepixels);
5897
5898         return skinframe;
5899 }
5900
5901 // this is only used by .spr32 sprites, HL .spr files, HL .bsp files
5902 skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, const unsigned char *skindata, int width, int height)
5903 {
5904         int i;
5905         unsigned char *temp1, *temp2;
5906         skinframe_t *skinframe;
5907
5908         if (cls.state == ca_dedicated)
5909                 return NULL;
5910
5911         // if already loaded just return it, otherwise make a new skinframe
5912         skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height*4) : 0, true);
5913         if (skinframe && skinframe->base)
5914                 return skinframe;
5915
5916         skinframe->stain = NULL;
5917         skinframe->merged = NULL;
5918         skinframe->base = NULL;
5919         skinframe->pants = NULL;
5920         skinframe->shirt = NULL;
5921         skinframe->nmap = NULL;
5922         skinframe->gloss = NULL;
5923         skinframe->glow = NULL;
5924         skinframe->fog = NULL;
5925         skinframe->reflect = NULL;
5926         skinframe->hasalpha = false;
5927
5928         // if no data was provided, then clearly the caller wanted to get a blank skinframe
5929         if (!skindata)
5930                 return NULL;
5931
5932         if (developer_loading.integer)
5933                 Con_Printf("loading 32bit skin \"%s\"\n", name);
5934
5935         if (r_loadnormalmap && r_shadow_bumpscale_basetexture.value > 0)
5936         {
5937                 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
5938                 temp2 = temp1 + width * height * 4;
5939                 Image_HeightmapToNormalmap_BGRA(skindata, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
5940                 skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, (textureflags | TEXF_ALPHA) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP), -1, NULL);
5941                 Mem_Free(temp1);
5942         }
5943         skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_BGRA, textureflags, -1, NULL);
5944         if (textureflags & TEXF_ALPHA)
5945         {
5946                 for (i = 3;i < width * height * 4;i += 4)
5947                 {
5948                         if (skindata[i] < 255)
5949                         {
5950                                 skinframe->hasalpha = true;
5951                                 break;
5952                         }
5953                 }
5954                 if (r_loadfog && skinframe->hasalpha)
5955                 {
5956                         unsigned char *fogpixels = (unsigned char *)Mem_Alloc(tempmempool, width * height * 4);
5957                         memcpy(fogpixels, skindata, width * height * 4);
5958                         for (i = 0;i < width * height * 4;i += 4)
5959                                 fogpixels[i] = fogpixels[i+1] = fogpixels[i+2] = 255;
5960                         skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, fogpixels, TEXTYPE_BGRA, textureflags, -1, NULL);
5961                         Mem_Free(fogpixels);
5962                 }
5963         }
5964
5965         R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, skindata[4 * pix + comp]);
5966         //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]);
5967
5968         return skinframe;
5969 }
5970
5971 skinframe_t *R_SkinFrame_LoadInternalQuake(const char *name, int textureflags, int loadpantsandshirt, int loadglowtexture, const unsigned char *skindata, int width, int height)
5972 {
5973         int i;
5974         int featuresmask;
5975         skinframe_t *skinframe;
5976
5977         if (cls.state == ca_dedicated)
5978                 return NULL;
5979
5980         // if already loaded just return it, otherwise make a new skinframe
5981         skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height) : 0, true);
5982         if (skinframe && skinframe->base)
5983                 return skinframe;
5984
5985         skinframe->stain = NULL;
5986         skinframe->merged = NULL;
5987         skinframe->base = NULL;
5988         skinframe->pants = NULL;
5989         skinframe->shirt = NULL;
5990         skinframe->nmap = NULL;
5991         skinframe->gloss = NULL;
5992         skinframe->glow = NULL;
5993         skinframe->fog = NULL;
5994         skinframe->reflect = NULL;
5995         skinframe->hasalpha = false;
5996
5997         // if no data was provided, then clearly the caller wanted to get a blank skinframe
5998         if (!skindata)
5999                 return NULL;
6000
6001         if (developer_loading.integer)
6002                 Con_Printf("loading quake skin \"%s\"\n", name);
6003
6004         // we actually don't upload anything until the first use, because mdl skins frequently go unused, and are almost never used in both modes (colormapped and non-colormapped)
6005         skinframe->qpixels = Mem_Alloc(r_main_mempool, width*height);
6006         memcpy(skinframe->qpixels, skindata, width*height);
6007         skinframe->qwidth = width;
6008         skinframe->qheight = height;
6009
6010         featuresmask = 0;
6011         for (i = 0;i < width * height;i++)
6012                 featuresmask |= palette_featureflags[skindata[i]];
6013
6014         skinframe->hasalpha = false;
6015         skinframe->qhascolormapping = loadpantsandshirt && (featuresmask & (PALETTEFEATURE_PANTS | PALETTEFEATURE_SHIRT));
6016         skinframe->qgeneratenmap = r_shadow_bumpscale_basetexture.value > 0;
6017         skinframe->qgeneratemerged = true;
6018         skinframe->qgeneratebase = skinframe->qhascolormapping;
6019         skinframe->qgenerateglow = loadglowtexture && (featuresmask & PALETTEFEATURE_GLOW);
6020
6021         R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, ((unsigned char *)palette_bgra_complete)[skindata[pix]*4 + comp]);
6022         //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]);
6023
6024         return skinframe;
6025 }
6026
6027 static void R_SkinFrame_GenerateTexturesFromQPixels(skinframe_t *skinframe, qboolean colormapped)
6028 {
6029         int width;
6030         int height;
6031         unsigned char *skindata;
6032
6033         if (!skinframe->qpixels)
6034                 return;
6035
6036         if (!skinframe->qhascolormapping)
6037                 colormapped = false;
6038
6039         if (colormapped)
6040         {
6041                 if (!skinframe->qgeneratebase)
6042                         return;
6043         }
6044         else
6045         {
6046                 if (!skinframe->qgeneratemerged)
6047                         return;
6048         }
6049
6050         width = skinframe->qwidth;
6051         height = skinframe->qheight;
6052         skindata = skinframe->qpixels;
6053
6054         if (skinframe->qgeneratenmap)
6055         {
6056                 unsigned char *temp1, *temp2;
6057                 skinframe->qgeneratenmap = false;
6058                 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
6059                 temp2 = temp1 + width * height * 4;
6060                 // use either a custom palette or the quake palette
6061                 Image_Copy8bitBGRA(skindata, temp1, width * height, palette_bgra_complete);
6062                 Image_HeightmapToNormalmap_BGRA(temp1, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
6063                 skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, (skinframe->textureflags | TEXF_ALPHA) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP), -1, NULL);
6064                 Mem_Free(temp1);
6065         }
6066
6067         if (skinframe->qgenerateglow)
6068         {
6069                 skinframe->qgenerateglow = false;
6070                 skinframe->glow = R_LoadTexture2D(r_main_texturepool, va("%s_glow", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, -1, palette_bgra_onlyfullbrights); // glow
6071         }
6072
6073         if (colormapped)
6074         {
6075                 skinframe->qgeneratebase = false;
6076                 skinframe->base  = R_LoadTexture2D(r_main_texturepool, va("%s_nospecial", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, -1, skinframe->glow ? palette_bgra_nocolormapnofullbrights : palette_bgra_nocolormap);
6077                 skinframe->pants = R_LoadTexture2D(r_main_texturepool, va("%s_pants", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, -1, palette_bgra_pantsaswhite);
6078                 skinframe->shirt = R_LoadTexture2D(r_main_texturepool, va("%s_shirt", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, -1, palette_bgra_shirtaswhite);
6079         }
6080         else
6081         {
6082                 skinframe->qgeneratemerged = false;
6083                 skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, -1, skinframe->glow ? palette_bgra_nofullbrights : palette_bgra_complete);
6084         }
6085
6086         if (!skinframe->qgeneratemerged && !skinframe->qgeneratebase)
6087         {
6088                 Mem_Free(skinframe->qpixels);
6089                 skinframe->qpixels = NULL;
6090         }
6091 }
6092
6093 skinframe_t *R_SkinFrame_LoadInternal8bit(const char *name, int textureflags, const unsigned char *skindata, int width, int height, const unsigned int *palette, const unsigned int *alphapalette)
6094 {
6095         int i;
6096         skinframe_t *skinframe;
6097
6098         if (cls.state == ca_dedicated)
6099                 return NULL;
6100
6101         // if already loaded just return it, otherwise make a new skinframe
6102         skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height) : 0, true);
6103         if (skinframe && skinframe->base)
6104                 return skinframe;
6105
6106         skinframe->stain = NULL;
6107         skinframe->merged = NULL;
6108         skinframe->base = NULL;
6109         skinframe->pants = NULL;
6110         skinframe->shirt = NULL;
6111         skinframe->nmap = NULL;
6112         skinframe->gloss = NULL;
6113         skinframe->glow = NULL;
6114         skinframe->fog = NULL;
6115         skinframe->reflect = NULL;
6116         skinframe->hasalpha = false;
6117
6118         // if no data was provided, then clearly the caller wanted to get a blank skinframe
6119         if (!skindata)
6120                 return NULL;
6121
6122         if (developer_loading.integer)
6123                 Con_Printf("loading embedded 8bit image \"%s\"\n", name);
6124
6125         skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_PALETTE, textureflags, -1, palette);
6126         if (textureflags & TEXF_ALPHA)
6127         {
6128                 for (i = 0;i < width * height;i++)
6129                 {
6130                         if (((unsigned char *)palette)[skindata[i]*4+3] < 255)
6131                         {
6132                                 skinframe->hasalpha = true;
6133                                 break;
6134                         }
6135                 }
6136                 if (r_loadfog && skinframe->hasalpha)
6137                         skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, textureflags, -1, alphapalette);
6138         }
6139
6140         R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, ((unsigned char *)palette)[skindata[pix]*4 + comp]);
6141         //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]);
6142
6143         return skinframe;
6144 }
6145
6146 skinframe_t *R_SkinFrame_LoadMissing(void)
6147 {
6148         skinframe_t *skinframe;
6149
6150         if (cls.state == ca_dedicated)
6151                 return NULL;
6152
6153         skinframe = R_SkinFrame_Find("missing", TEXF_FORCENEAREST, 0, 0, 0, true);
6154         skinframe->stain = NULL;
6155         skinframe->merged = NULL;
6156         skinframe->base = NULL;
6157         skinframe->pants = NULL;
6158         skinframe->shirt = NULL;
6159         skinframe->nmap = NULL;
6160         skinframe->gloss = NULL;
6161         skinframe->glow = NULL;
6162         skinframe->fog = NULL;
6163         skinframe->reflect = NULL;
6164         skinframe->hasalpha = false;
6165
6166         skinframe->avgcolor[0] = rand() / RAND_MAX;
6167         skinframe->avgcolor[1] = rand() / RAND_MAX;
6168         skinframe->avgcolor[2] = rand() / RAND_MAX;
6169         skinframe->avgcolor[3] = 1;
6170
6171         return skinframe;
6172 }
6173
6174 //static char *suffix[6] = {"ft", "bk", "rt", "lf", "up", "dn"};
6175 typedef struct suffixinfo_s
6176 {
6177         char *suffix;
6178         qboolean flipx, flipy, flipdiagonal;
6179 }
6180 suffixinfo_t;
6181 static suffixinfo_t suffix[3][6] =
6182 {
6183         {
6184                 {"px",   false, false, false},
6185                 {"nx",   false, false, false},
6186                 {"py",   false, false, false},
6187                 {"ny",   false, false, false},
6188                 {"pz",   false, false, false},
6189                 {"nz",   false, false, false}
6190         },
6191         {
6192                 {"posx", false, false, false},
6193                 {"negx", false, false, false},
6194                 {"posy", false, false, false},
6195                 {"negy", false, false, false},
6196                 {"posz", false, false, false},
6197                 {"negz", false, false, false}
6198         },
6199         {
6200                 {"rt",    true, false,  true},
6201                 {"lf",   false,  true,  true},
6202                 {"ft",    true,  true, false},
6203                 {"bk",   false, false, false},
6204                 {"up",    true, false,  true},
6205                 {"dn",    true, false,  true}
6206         }
6207 };
6208
6209 static int componentorder[4] = {0, 1, 2, 3};
6210
6211 rtexture_t *R_LoadCubemap(const char *basename)
6212 {
6213         int i, j, cubemapsize;
6214         unsigned char *cubemappixels, *image_buffer;
6215         rtexture_t *cubemaptexture;
6216         char name[256];
6217         // must start 0 so the first loadimagepixels has no requested width/height
6218         cubemapsize = 0;
6219         cubemappixels = NULL;
6220         cubemaptexture = NULL;
6221         // keep trying different suffix groups (posx, px, rt) until one loads
6222         for (j = 0;j < 3 && !cubemappixels;j++)
6223         {
6224                 // load the 6 images in the suffix group
6225                 for (i = 0;i < 6;i++)
6226                 {
6227                         // generate an image name based on the base and and suffix
6228                         dpsnprintf(name, sizeof(name), "%s%s", basename, suffix[j][i].suffix);
6229                         // load it
6230                         if ((image_buffer = loadimagepixelsbgra(name, false, false, r_texture_convertsRGB_cubemap.integer, NULL)))
6231                         {
6232                                 // an image loaded, make sure width and height are equal
6233                                 if (image_width == image_height && (!cubemappixels || image_width == cubemapsize))
6234                                 {
6235                                         // if this is the first image to load successfully, allocate the cubemap memory
6236                                         if (!cubemappixels && image_width >= 1)
6237                                         {
6238                                                 cubemapsize = image_width;
6239                                                 // note this clears to black, so unavailable sides are black
6240                                                 cubemappixels = (unsigned char *)Mem_Alloc(tempmempool, 6*cubemapsize*cubemapsize*4);
6241                                         }
6242                                         // copy the image with any flipping needed by the suffix (px and posx types don't need flipping)
6243                                         if (cubemappixels)
6244                                                 Image_CopyMux(cubemappixels+i*cubemapsize*cubemapsize*4, image_buffer, cubemapsize, cubemapsize, suffix[j][i].flipx, suffix[j][i].flipy, suffix[j][i].flipdiagonal, 4, 4, componentorder);
6245                                 }
6246                                 else
6247                                         Con_Printf("Cubemap image \"%s\" (%ix%i) is not square, OpenGL requires square cubemaps.\n", name, image_width, image_height);
6248                                 // free the image
6249                                 Mem_Free(image_buffer);
6250                         }
6251                 }
6252         }
6253         // if a cubemap loaded, upload it
6254         if (cubemappixels)
6255         {
6256                 if (developer_loading.integer)
6257                         Con_Printf("loading cubemap \"%s\"\n", basename);
6258
6259                 cubemaptexture = R_LoadTextureCubeMap(r_main_texturepool, basename, cubemapsize, cubemappixels, TEXTYPE_BGRA, (gl_texturecompression_lightcubemaps.integer ? TEXF_COMPRESS : 0) | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
6260                 Mem_Free(cubemappixels);
6261         }
6262         else
6263         {
6264                 Con_DPrintf("failed to load cubemap \"%s\"\n", basename);
6265                 if (developer_loading.integer)
6266                 {
6267                         Con_Printf("(tried tried images ");
6268                         for (j = 0;j < 3;j++)
6269                                 for (i = 0;i < 6;i++)
6270                                         Con_Printf("%s\"%s%s.tga\"", j + i > 0 ? ", " : "", basename, suffix[j][i].suffix);
6271                         Con_Print(" and was unable to find any of them).\n");
6272                 }
6273         }
6274         return cubemaptexture;
6275 }
6276
6277 rtexture_t *R_GetCubemap(const char *basename)
6278 {
6279         int i;
6280         for (i = 0;i < r_texture_numcubemaps;i++)
6281                 if (!strcasecmp(r_texture_cubemaps[i].basename, basename))
6282                         return r_texture_cubemaps[i].texture ? r_texture_cubemaps[i].texture : r_texture_whitecube;
6283         if (i >= MAX_CUBEMAPS)
6284                 return r_texture_whitecube;
6285         r_texture_numcubemaps++;
6286         strlcpy(r_texture_cubemaps[i].basename, basename, sizeof(r_texture_cubemaps[i].basename));
6287         r_texture_cubemaps[i].texture = R_LoadCubemap(r_texture_cubemaps[i].basename);
6288         return r_texture_cubemaps[i].texture;
6289 }
6290
6291 void R_FreeCubemaps(void)
6292 {
6293         int i;
6294         for (i = 0;i < r_texture_numcubemaps;i++)
6295         {
6296                 if (developer_loading.integer)
6297                         Con_DPrintf("unloading cubemap \"%s\"\n", r_texture_cubemaps[i].basename);
6298                 if (r_texture_cubemaps[i].texture)
6299                         R_FreeTexture(r_texture_cubemaps[i].texture);
6300         }
6301         r_texture_numcubemaps = 0;
6302 }
6303
6304 void R_Main_FreeViewCache(void)
6305 {
6306         if (r_refdef.viewcache.entityvisible)
6307                 Mem_Free(r_refdef.viewcache.entityvisible);
6308         if (r_refdef.viewcache.world_pvsbits)
6309                 Mem_Free(r_refdef.viewcache.world_pvsbits);
6310         if (r_refdef.viewcache.world_leafvisible)
6311                 Mem_Free(r_refdef.viewcache.world_leafvisible);
6312         if (r_refdef.viewcache.world_surfacevisible)
6313                 Mem_Free(r_refdef.viewcache.world_surfacevisible);
6314         memset(&r_refdef.viewcache, 0, sizeof(r_refdef.viewcache));
6315 }
6316
6317 void R_Main_ResizeViewCache(void)
6318 {
6319         int numentities = r_refdef.scene.numentities;
6320         int numclusters = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_pvsclusters : 1;
6321         int numclusterbytes = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_pvsclusterbytes : 1;
6322         int numleafs = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_leafs : 1;
6323         int numsurfaces = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->num_surfaces : 1;
6324         if (r_refdef.viewcache.maxentities < numentities)
6325         {
6326                 r_refdef.viewcache.maxentities = numentities;
6327                 if (r_refdef.viewcache.entityvisible)
6328                         Mem_Free(r_refdef.viewcache.entityvisible);
6329                 r_refdef.viewcache.entityvisible = Mem_Alloc(r_main_mempool, r_refdef.viewcache.maxentities);
6330         }
6331         if (r_refdef.viewcache.world_numclusters != numclusters)
6332         {
6333                 r_refdef.viewcache.world_numclusters = numclusters;
6334                 r_refdef.viewcache.world_numclusterbytes = numclusterbytes;
6335                 if (r_refdef.viewcache.world_pvsbits)
6336                         Mem_Free(r_refdef.viewcache.world_pvsbits);
6337                 r_refdef.viewcache.world_pvsbits = Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numclusterbytes);
6338         }
6339         if (r_refdef.viewcache.world_numleafs != numleafs)
6340         {
6341                 r_refdef.viewcache.world_numleafs = numleafs;
6342                 if (r_refdef.viewcache.world_leafvisible)
6343                         Mem_Free(r_refdef.viewcache.world_leafvisible);
6344                 r_refdef.viewcache.world_leafvisible = Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numleafs);
6345         }
6346         if (r_refdef.viewcache.world_numsurfaces != numsurfaces)
6347         {
6348                 r_refdef.viewcache.world_numsurfaces = numsurfaces;
6349                 if (r_refdef.viewcache.world_surfacevisible)
6350                         Mem_Free(r_refdef.viewcache.world_surfacevisible);
6351                 r_refdef.viewcache.world_surfacevisible = Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numsurfaces);
6352         }
6353 }
6354
6355 extern rtexture_t *loadingscreentexture;
6356 void gl_main_start(void)
6357 {
6358         loadingscreentexture = NULL;
6359         r_texture_blanknormalmap = NULL;
6360         r_texture_white = NULL;
6361         r_texture_grey128 = NULL;
6362         r_texture_black = NULL;
6363         r_texture_whitecube = NULL;
6364         r_texture_normalizationcube = NULL;
6365         r_texture_fogattenuation = NULL;
6366         r_texture_fogheighttexture = NULL;
6367         r_texture_gammaramps = NULL;
6368         r_texture_numcubemaps = 0;
6369
6370         r_loaddds = vid.support.arb_texture_compression && vid.support.ext_texture_compression_s3tc && r_texture_dds_load.integer;
6371         r_savedds = vid.support.arb_texture_compression && vid.support.ext_texture_compression_s3tc && r_texture_dds_save.integer;
6372
6373         switch(vid.renderpath)
6374         {
6375         case RENDERPATH_GL20:
6376         case RENDERPATH_CGGL:
6377                 Cvar_SetValueQuick(&r_textureunits, vid.texunits);
6378                 Cvar_SetValueQuick(&gl_combine, 1);
6379                 Cvar_SetValueQuick(&r_glsl, 1);
6380                 r_loadnormalmap = true;
6381                 r_loadgloss = true;
6382                 r_loadfog = false;
6383                 break;
6384         case RENDERPATH_GL13:
6385                 Cvar_SetValueQuick(&r_textureunits, vid.texunits);
6386                 Cvar_SetValueQuick(&gl_combine, 1);
6387                 Cvar_SetValueQuick(&r_glsl, 0);
6388                 r_loadnormalmap = false;
6389                 r_loadgloss = false;
6390                 r_loadfog = true;
6391                 break;
6392         case RENDERPATH_GL11:
6393                 Cvar_SetValueQuick(&r_textureunits, vid.texunits);
6394                 Cvar_SetValueQuick(&gl_combine, 0);
6395                 Cvar_SetValueQuick(&r_glsl, 0);
6396                 r_loadnormalmap = false;
6397                 r_loadgloss = false;
6398                 r_loadfog = true;
6399                 break;
6400         }
6401
6402         R_AnimCache_Free();
6403         R_FrameData_Reset();
6404
6405         r_numqueries = 0;
6406         r_maxqueries = 0;
6407         memset(r_queries, 0, sizeof(r_queries));
6408
6409         r_qwskincache = NULL;
6410         r_qwskincache_size = 0;
6411
6412         // set up r_skinframe loading system for textures
6413         memset(&r_skinframe, 0, sizeof(r_skinframe));
6414         r_skinframe.loadsequence = 1;
6415         Mem_ExpandableArray_NewArray(&r_skinframe.array, r_main_mempool, sizeof(skinframe_t), 256);
6416
6417         r_main_texturepool = R_AllocTexturePool();
6418         R_BuildBlankTextures();
6419         R_BuildNoTexture();
6420         if (vid.support.arb_texture_cube_map)
6421         {
6422                 R_BuildWhiteCube();
6423                 R_BuildNormalizationCube();
6424         }
6425         r_texture_fogattenuation = NULL;
6426         r_texture_fogheighttexture = NULL;
6427         r_texture_gammaramps = NULL;
6428         //r_texture_fogintensity = NULL;
6429         memset(&r_bloomstate, 0, sizeof(r_bloomstate));
6430         memset(&r_waterstate, 0, sizeof(r_waterstate));
6431         r_glsl_permutation = NULL;
6432         memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash));
6433         Mem_ExpandableArray_NewArray(&r_glsl_permutationarray, r_main_mempool, sizeof(r_glsl_permutation_t), 256);
6434         glslshaderstring = NULL;
6435 #ifdef SUPPORTCG
6436         r_cg_permutation = NULL;
6437         memset(r_cg_permutationhash, 0, sizeof(r_cg_permutationhash));
6438         Mem_ExpandableArray_NewArray(&r_cg_permutationarray, r_main_mempool, sizeof(r_cg_permutation_t), 256);
6439         cgshaderstring = NULL;
6440 #endif
6441         memset(&r_svbsp, 0, sizeof (r_svbsp));
6442
6443         r_refdef.fogmasktable_density = 0;
6444 }
6445
6446 void gl_main_shutdown(void)
6447 {
6448         R_AnimCache_Free();
6449         R_FrameData_Reset();
6450
6451         R_Main_FreeViewCache();
6452
6453         if (r_maxqueries)
6454                 qglDeleteQueriesARB(r_maxqueries, r_queries);
6455
6456         r_numqueries = 0;
6457         r_maxqueries = 0;
6458         memset(r_queries, 0, sizeof(r_queries));
6459
6460         r_qwskincache = NULL;
6461         r_qwskincache_size = 0;
6462
6463         // clear out the r_skinframe state
6464         Mem_ExpandableArray_FreeArray(&r_skinframe.array);
6465         memset(&r_skinframe, 0, sizeof(r_skinframe));
6466
6467         if (r_svbsp.nodes)
6468                 Mem_Free(r_svbsp.nodes);
6469         memset(&r_svbsp, 0, sizeof (r_svbsp));
6470         R_FreeTexturePool(&r_main_texturepool);
6471         loadingscreentexture = NULL;
6472         r_texture_blanknormalmap = NULL;
6473         r_texture_white = NULL;
6474         r_texture_grey128 = NULL;
6475         r_texture_black = NULL;
6476         r_texture_whitecube = NULL;
6477         r_texture_normalizationcube = NULL;
6478         r_texture_fogattenuation = NULL;
6479         r_texture_fogheighttexture = NULL;
6480         r_texture_gammaramps = NULL;
6481         r_texture_numcubemaps = 0;
6482         //r_texture_fogintensity = NULL;
6483         memset(&r_bloomstate, 0, sizeof(r_bloomstate));
6484         memset(&r_waterstate, 0, sizeof(r_waterstate));
6485         r_glsl_permutation = NULL;
6486         memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash));
6487         glslshaderstring = NULL;
6488 #ifdef SUPPORTCG
6489         r_cg_permutation = NULL;
6490         memset(r_cg_permutationhash, 0, sizeof(r_cg_permutationhash));
6491         cgshaderstring = NULL;
6492 #endif
6493         R_GLSL_Restart_f();
6494 }
6495
6496 extern void CL_ParseEntityLump(char *entitystring);
6497 void gl_main_newmap(void)
6498 {
6499         // FIXME: move this code to client
6500         char *entities, entname[MAX_QPATH];
6501         if (r_qwskincache)
6502                 Mem_Free(r_qwskincache);
6503         r_qwskincache = NULL;
6504         r_qwskincache_size = 0;
6505         if (cl.worldmodel)
6506         {
6507                 dpsnprintf(entname, sizeof(entname), "%s.ent", cl.worldnamenoextension);
6508                 if ((entities = (char *)FS_LoadFile(entname, tempmempool, true, NULL)))
6509                 {
6510                         CL_ParseEntityLump(entities);
6511                         Mem_Free(entities);
6512                         return;
6513                 }
6514                 if (cl.worldmodel->brush.entities)
6515                         CL_ParseEntityLump(cl.worldmodel->brush.entities);
6516         }
6517         R_Main_FreeViewCache();
6518
6519         R_FrameData_Reset();
6520 }
6521
6522 void GL_Main_Init(void)
6523 {
6524         r_main_mempool = Mem_AllocPool("Renderer", 0, NULL);
6525
6526         Cmd_AddCommand("r_glsl_restart", R_GLSL_Restart_f, "unloads GLSL shaders, they will then be reloaded as needed");
6527         Cmd_AddCommand("r_glsl_dumpshader", R_GLSL_DumpShader_f, "dumps the engine internal default.glsl shader into glsl/default.glsl");
6528         // FIXME: the client should set up r_refdef.fog stuff including the fogmasktable
6529         if (gamemode == GAME_NEHAHRA)
6530         {
6531                 Cvar_RegisterVariable (&gl_fogenable);
6532                 Cvar_RegisterVariable (&gl_fogdensity);
6533                 Cvar_RegisterVariable (&gl_fogred);
6534                 Cvar_RegisterVariable (&gl_foggreen);
6535                 Cvar_RegisterVariable (&gl_fogblue);
6536                 Cvar_RegisterVariable (&gl_fogstart);
6537                 Cvar_RegisterVariable (&gl_fogend);
6538                 Cvar_RegisterVariable (&gl_skyclip);
6539         }
6540         Cvar_RegisterVariable(&r_motionblur);
6541         Cvar_RegisterVariable(&r_motionblur_maxblur);
6542         Cvar_RegisterVariable(&r_motionblur_bmin);
6543         Cvar_RegisterVariable(&r_motionblur_vmin);
6544         Cvar_RegisterVariable(&r_motionblur_vmax);
6545         Cvar_RegisterVariable(&r_motionblur_vcoeff);
6546         Cvar_RegisterVariable(&r_motionblur_randomize);
6547         Cvar_RegisterVariable(&r_damageblur);
6548         Cvar_RegisterVariable(&r_equalize_entities_fullbright);
6549         Cvar_RegisterVariable(&r_equalize_entities_minambient);
6550         Cvar_RegisterVariable(&r_equalize_entities_by);
6551         Cvar_RegisterVariable(&r_equalize_entities_to);
6552         Cvar_RegisterVariable(&r_depthfirst);
6553         Cvar_RegisterVariable(&r_useinfinitefarclip);
6554         Cvar_RegisterVariable(&r_farclip_base);
6555         Cvar_RegisterVariable(&r_farclip_world);
6556         Cvar_RegisterVariable(&r_nearclip);
6557         Cvar_RegisterVariable(&r_showbboxes);
6558         Cvar_RegisterVariable(&r_showsurfaces);
6559         Cvar_RegisterVariable(&r_showtris);
6560         Cvar_RegisterVariable(&r_shownormals);
6561         Cvar_RegisterVariable(&r_showlighting);
6562         Cvar_RegisterVariable(&r_showshadowvolumes);
6563         Cvar_RegisterVariable(&r_showcollisionbrushes);
6564         Cvar_RegisterVariable(&r_showcollisionbrushes_polygonfactor);
6565         Cvar_RegisterVariable(&r_showcollisionbrushes_polygonoffset);
6566         Cvar_RegisterVariable(&r_showdisabledepthtest);
6567         Cvar_RegisterVariable(&r_drawportals);
6568         Cvar_RegisterVariable(&r_drawentities);
6569         Cvar_RegisterVariable(&r_draw2d);
6570         Cvar_RegisterVariable(&r_drawworld);
6571         Cvar_RegisterVariable(&r_cullentities_trace);
6572         Cvar_RegisterVariable(&r_cullentities_trace_samples);
6573         Cvar_RegisterVariable(&r_cullentities_trace_tempentitysamples);
6574         Cvar_RegisterVariable(&r_cullentities_trace_enlarge);
6575         Cvar_RegisterVariable(&r_cullentities_trace_delay);
6576         Cvar_RegisterVariable(&r_drawviewmodel);
6577         Cvar_RegisterVariable(&r_drawexteriormodel);
6578         Cvar_RegisterVariable(&r_speeds);
6579         Cvar_RegisterVariable(&r_fullbrights);
6580         Cvar_RegisterVariable(&r_wateralpha);
6581         Cvar_RegisterVariable(&r_dynamic);
6582         Cvar_RegisterVariable(&r_fullbright);
6583         Cvar_RegisterVariable(&r_shadows);
6584         Cvar_RegisterVariable(&r_shadows_darken);
6585         Cvar_RegisterVariable(&r_shadows_drawafterrtlighting);
6586         Cvar_RegisterVariable(&r_shadows_castfrombmodels);
6587         Cvar_RegisterVariable(&r_shadows_throwdistance);
6588         Cvar_RegisterVariable(&r_shadows_throwdirection);
6589         Cvar_RegisterVariable(&r_shadows_focus);
6590         Cvar_RegisterVariable(&r_shadows_shadowmapscale);
6591         Cvar_RegisterVariable(&r_q1bsp_skymasking);
6592         Cvar_RegisterVariable(&r_polygonoffset_submodel_factor);
6593         Cvar_RegisterVariable(&r_polygonoffset_submodel_offset);
6594         Cvar_RegisterVariable(&r_polygonoffset_decals_factor);
6595         Cvar_RegisterVariable(&r_polygonoffset_decals_offset);
6596         Cvar_RegisterVariable(&r_fog_exp2);
6597         Cvar_RegisterVariable(&r_drawfog);
6598         Cvar_RegisterVariable(&r_transparentdepthmasking);
6599         Cvar_RegisterVariable(&r_texture_dds_load);
6600         Cvar_RegisterVariable(&r_texture_dds_save);
6601         Cvar_RegisterVariable(&r_texture_convertsRGB_2d);
6602         Cvar_RegisterVariable(&r_texture_convertsRGB_skin);
6603         Cvar_RegisterVariable(&r_texture_convertsRGB_cubemap);
6604         Cvar_RegisterVariable(&r_texture_convertsRGB_skybox);
6605         Cvar_RegisterVariable(&r_texture_convertsRGB_particles);
6606         Cvar_RegisterVariable(&r_textureunits);
6607         Cvar_RegisterVariable(&gl_combine);
6608         Cvar_RegisterVariable(&r_glsl);
6609         Cvar_RegisterVariable(&r_glsl_deluxemapping);
6610         Cvar_RegisterVariable(&r_glsl_offsetmapping);
6611         Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping);
6612         Cvar_RegisterVariable(&r_glsl_offsetmapping_scale);
6613         Cvar_RegisterVariable(&r_glsl_postprocess);
6614         Cvar_RegisterVariable(&r_glsl_postprocess_uservec1);
6615         Cvar_RegisterVariable(&r_glsl_postprocess_uservec2);
6616         Cvar_RegisterVariable(&r_glsl_postprocess_uservec3);
6617         Cvar_RegisterVariable(&r_glsl_postprocess_uservec4);
6618         Cvar_RegisterVariable(&r_water);
6619         Cvar_RegisterVariable(&r_water_resolutionmultiplier);
6620         Cvar_RegisterVariable(&r_water_clippingplanebias);
6621         Cvar_RegisterVariable(&r_water_refractdistort);
6622         Cvar_RegisterVariable(&r_water_reflectdistort);
6623         Cvar_RegisterVariable(&r_lerpsprites);
6624         Cvar_RegisterVariable(&r_lerpmodels);
6625         Cvar_RegisterVariable(&r_lerplightstyles);
6626         Cvar_RegisterVariable(&r_waterscroll);
6627         Cvar_RegisterVariable(&r_bloom);
6628         Cvar_RegisterVariable(&r_bloom_colorscale);
6629         Cvar_RegisterVariable(&r_bloom_brighten);
6630         Cvar_RegisterVariable(&r_bloom_blur);
6631         Cvar_RegisterVariable(&r_bloom_resolution);
6632         Cvar_RegisterVariable(&r_bloom_colorexponent);
6633         Cvar_RegisterVariable(&r_bloom_colorsubtract);
6634         Cvar_RegisterVariable(&r_hdr);
6635         Cvar_RegisterVariable(&r_hdr_scenebrightness);
6636         Cvar_RegisterVariable(&r_hdr_glowintensity);
6637         Cvar_RegisterVariable(&r_hdr_range);
6638         Cvar_RegisterVariable(&r_smoothnormals_areaweighting);
6639         Cvar_RegisterVariable(&developer_texturelogging);
6640         Cvar_RegisterVariable(&gl_lightmaps);
6641         Cvar_RegisterVariable(&r_test);
6642         Cvar_RegisterVariable(&r_batchmode);
6643         Cvar_RegisterVariable(&r_glsl_saturation);
6644         Cvar_RegisterVariable(&r_framedatasize);
6645         if (gamemode == GAME_NEHAHRA || gamemode == GAME_TENEBRAE)
6646                 Cvar_SetValue("r_fullbrights", 0);
6647         R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap, NULL, NULL);
6648
6649         Cvar_RegisterVariable(&r_track_sprites);
6650         Cvar_RegisterVariable(&r_track_sprites_flags);
6651         Cvar_RegisterVariable(&r_track_sprites_scalew);
6652         Cvar_RegisterVariable(&r_track_sprites_scaleh);
6653         Cvar_RegisterVariable(&r_overheadsprites_perspective);
6654         Cvar_RegisterVariable(&r_overheadsprites_pushback);
6655 }
6656
6657 extern void R_Textures_Init(void);
6658 extern void GL_Draw_Init(void);
6659 extern void GL_Main_Init(void);
6660 extern void R_Shadow_Init(void);
6661 extern void R_Sky_Init(void);
6662 extern void GL_Surf_Init(void);
6663 extern void R_Particles_Init(void);
6664 extern void R_Explosion_Init(void);
6665 extern void gl_backend_init(void);
6666 extern void Sbar_Init(void);
6667 extern void R_LightningBeams_Init(void);
6668 extern void Mod_RenderInit(void);
6669 extern void Font_Init(void);
6670
6671 void Render_Init(void)
6672 {
6673         gl_backend_init();
6674         R_Textures_Init();
6675         GL_Main_Init();
6676         Font_Init();
6677         GL_Draw_Init();
6678         R_Shadow_Init();
6679         R_Sky_Init();
6680         GL_Surf_Init();
6681         Sbar_Init();
6682         R_Particles_Init();
6683         R_Explosion_Init();
6684         R_LightningBeams_Init();
6685         Mod_RenderInit();
6686 }
6687
6688 /*
6689 ===============
6690 GL_Init
6691 ===============
6692 */
6693 extern char *ENGINE_EXTENSIONS;
6694 void GL_Init (void)
6695 {
6696         gl_renderer = (const char *)qglGetString(GL_RENDERER);
6697         gl_vendor = (const char *)qglGetString(GL_VENDOR);
6698         gl_version = (const char *)qglGetString(GL_VERSION);
6699         gl_extensions = (const char *)qglGetString(GL_EXTENSIONS);
6700
6701         if (!gl_extensions)
6702                 gl_extensions = "";
6703         if (!gl_platformextensions)
6704                 gl_platformextensions = "";
6705
6706         Con_Printf("GL_VENDOR: %s\n", gl_vendor);
6707         Con_Printf("GL_RENDERER: %s\n", gl_renderer);
6708         Con_Printf("GL_VERSION: %s\n", gl_version);
6709         Con_DPrintf("GL_EXTENSIONS: %s\n", gl_extensions);
6710         Con_DPrintf("%s_EXTENSIONS: %s\n", gl_platform, gl_platformextensions);
6711
6712         VID_CheckExtensions();
6713
6714         // LordHavoc: report supported extensions
6715         Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
6716
6717         // clear to black (loading plaque will be seen over this)
6718         CHECKGLERROR
6719         qglClearColor(0,0,0,1);CHECKGLERROR
6720         qglClear(GL_COLOR_BUFFER_BIT);CHECKGLERROR
6721 }
6722
6723 int R_CullBox(const vec3_t mins, const vec3_t maxs)
6724 {
6725         int i;
6726         mplane_t *p;
6727         for (i = 0;i < r_refdef.view.numfrustumplanes;i++)
6728         {
6729                 // skip nearclip plane, it often culls portals when you are very close, and is almost never useful
6730                 if (i == 4)
6731                         continue;
6732                 p = r_refdef.view.frustum + i;
6733                 switch(p->signbits)
6734                 {
6735                 default:
6736                 case 0:
6737                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
6738                                 return true;
6739                         break;
6740                 case 1:
6741                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
6742                                 return true;
6743                         break;
6744                 case 2:
6745                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
6746                                 return true;
6747                         break;
6748                 case 3:
6749                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
6750                                 return true;
6751                         break;
6752                 case 4:
6753                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
6754                                 return true;
6755                         break;
6756                 case 5:
6757                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
6758                                 return true;
6759                         break;
6760                 case 6:
6761                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
6762                                 return true;
6763                         break;
6764                 case 7:
6765                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
6766                                 return true;
6767                         break;
6768                 }
6769         }
6770         return false;
6771 }
6772
6773 int R_CullBoxCustomPlanes(const vec3_t mins, const vec3_t maxs, int numplanes, const mplane_t *planes)
6774 {
6775         int i;
6776         const mplane_t *p;
6777         for (i = 0;i < numplanes;i++)
6778         {
6779                 p = planes + i;
6780                 switch(p->signbits)
6781                 {
6782                 default:
6783                 case 0:
6784                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
6785                                 return true;
6786                         break;
6787                 case 1:
6788                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
6789                                 return true;
6790                         break;
6791                 case 2:
6792                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
6793                                 return true;
6794                         break;
6795                 case 3:
6796                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
6797                                 return true;
6798                         break;
6799                 case 4:
6800                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
6801                                 return true;
6802                         break;
6803                 case 5:
6804                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
6805                                 return true;
6806                         break;
6807                 case 6:
6808                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
6809                                 return true;
6810                         break;
6811                 case 7:
6812                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
6813                                 return true;
6814                         break;
6815                 }
6816         }
6817         return false;
6818 }
6819
6820 //==================================================================================
6821
6822 // LordHavoc: this stores temporary data used within the same frame
6823
6824 qboolean r_framedata_failed;
6825 static size_t r_framedata_size;
6826 static size_t r_framedata_current;
6827 static void *r_framedata_base;
6828
6829 void R_FrameData_Reset(void)
6830 {
6831         if (r_framedata_base)
6832                 Mem_Free(r_framedata_base);
6833         r_framedata_base = NULL;
6834         r_framedata_size = 0;
6835         r_framedata_current = 0;
6836         r_framedata_failed = false;
6837 }
6838
6839 void R_FrameData_NewFrame(void)
6840 {
6841         size_t wantedsize;
6842         if (r_framedata_failed)
6843                 Cvar_SetValueQuick(&r_framedatasize, r_framedatasize.value + 1.0f);
6844         wantedsize = (size_t)(r_framedatasize.value * 1024*1024);
6845         wantedsize = bound(65536, wantedsize, 128*1024*1024);
6846         if (r_framedata_size != wantedsize)
6847         {
6848                 r_framedata_size = wantedsize;
6849                 if (r_framedata_base)
6850                         Mem_Free(r_framedata_base);
6851                 r_framedata_base = Mem_Alloc(r_main_mempool, r_framedata_size);
6852         }
6853         r_framedata_current = 0;
6854         r_framedata_failed = false;
6855 }
6856
6857 void *R_FrameData_Alloc(size_t size)
6858 {
6859         void *data;
6860
6861         // align to 16 byte boundary
6862         size = (size + 15) & ~15;
6863         data = (void *)((unsigned char*)r_framedata_base + r_framedata_current);
6864         r_framedata_current += size;
6865
6866         // check overflow
6867         if (r_framedata_current > r_framedata_size)
6868                 r_framedata_failed = true;
6869
6870         // return NULL on everything after a failure
6871         if (r_framedata_failed)
6872                 return NULL;
6873
6874         return data;
6875 }
6876
6877 void *R_FrameData_Store(size_t size, void *data)
6878 {
6879         void *d = R_FrameData_Alloc(size);
6880         if (d)
6881                 memcpy(d, data, size);
6882         return d;
6883 }
6884
6885 //==================================================================================
6886
6887 // LordHavoc: animcache originally written by Echon, rewritten since then
6888
6889 /**
6890  * Animation cache prevents re-generating mesh data for an animated model
6891  * multiple times in one frame for lighting, shadowing, reflections, etc.
6892  */
6893
6894 void R_AnimCache_Free(void)
6895 {
6896 }
6897
6898 void R_AnimCache_ClearCache(void)
6899 {
6900         int i;
6901         entity_render_t *ent;
6902
6903         for (i = 0;i < r_refdef.scene.numentities;i++)
6904         {
6905                 ent = r_refdef.scene.entities[i];
6906                 ent->animcache_vertex3f = NULL;
6907                 ent->animcache_normal3f = NULL;
6908                 ent->animcache_svector3f = NULL;
6909                 ent->animcache_tvector3f = NULL;
6910         }
6911 }
6912
6913 qboolean R_AnimCache_GetEntity(entity_render_t *ent, qboolean wantnormals, qboolean wanttangents)
6914 {
6915         dp_model_t *model = ent->model;
6916         int numvertices;
6917         // see if it's already cached this frame
6918         if (ent->animcache_vertex3f)
6919         {
6920                 // add normals/tangents if needed
6921                 if (wantnormals || wanttangents)
6922                 {
6923                         if (ent->animcache_normal3f)
6924                                 wantnormals = false;
6925                         if (ent->animcache_svector3f)
6926                                 wanttangents = false;
6927                         if (wantnormals || wanttangents)
6928                         {
6929                                 numvertices = model->surfmesh.num_vertices;
6930                                 if (wantnormals)
6931                                         ent->animcache_normal3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
6932                                 if (wanttangents)
6933                                 {
6934                                         ent->animcache_svector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
6935                                         ent->animcache_tvector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
6936                                 }
6937                                 if (!r_framedata_failed)
6938                                         model->AnimateVertices(model, ent->frameblend, ent->skeleton, NULL, wantnormals ? ent->animcache_normal3f : NULL, wanttangents ? ent->animcache_svector3f : NULL, wanttangents ? ent->animcache_tvector3f : NULL);
6939                         }
6940                 }
6941         }
6942         else
6943         {
6944                 // see if this ent is worth caching
6945                 if (!model || !model->Draw || !model->surfmesh.isanimated || !model->AnimateVertices || (ent->frameblend[0].lerp == 1 && ent->frameblend[0].subframe == 0 && !ent->skeleton))
6946                         return false;
6947                 // get some memory for this entity and generate mesh data
6948                 numvertices = model->surfmesh.num_vertices;
6949                 ent->animcache_vertex3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
6950                 if (wantnormals)
6951                         ent->animcache_normal3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
6952                 if (wanttangents)
6953                 {
6954                         ent->animcache_svector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
6955                         ent->animcache_tvector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
6956                 }
6957                 if (!r_framedata_failed)
6958                         model->AnimateVertices(model, ent->frameblend, ent->skeleton, ent->animcache_vertex3f, ent->animcache_normal3f, ent->animcache_svector3f, ent->animcache_tvector3f);
6959         }
6960         return !r_framedata_failed;
6961 }
6962
6963 void R_AnimCache_CacheVisibleEntities(void)
6964 {
6965         int i;
6966         qboolean wantnormals = !r_showsurfaces.integer;
6967         qboolean wanttangents = !r_showsurfaces.integer;
6968
6969         switch(vid.renderpath)
6970         {
6971         case RENDERPATH_GL20:
6972         case RENDERPATH_CGGL:
6973                 break;
6974         case RENDERPATH_GL13:
6975         case RENDERPATH_GL11:
6976                 wanttangents = false;
6977                 break;
6978         }
6979
6980         // TODO: thread this
6981         // NOTE: R_PrepareRTLights() also caches entities
6982
6983         for (i = 0;i < r_refdef.scene.numentities;i++)
6984                 if (r_refdef.viewcache.entityvisible[i])
6985                         R_AnimCache_GetEntity(r_refdef.scene.entities[i], wantnormals, wanttangents);
6986 }
6987
6988 //==================================================================================
6989
6990 static void R_View_UpdateEntityLighting (void)
6991 {
6992         int i;
6993         entity_render_t *ent;
6994         vec3_t tempdiffusenormal, avg;
6995         vec_t f, fa, fd, fdd;
6996         qboolean skipunseen = r_shadows.integer != 1; //|| R_Shadow_ShadowMappingEnabled();
6997
6998         for (i = 0;i < r_refdef.scene.numentities;i++)
6999         {
7000                 ent = r_refdef.scene.entities[i];
7001
7002                 // skip unseen models
7003                 if (!r_refdef.viewcache.entityvisible[i] && skipunseen)
7004                         continue;
7005
7006                 // skip bsp models
7007                 if (ent->model && ent->model->brush.num_leafs)
7008                 {
7009                         // TODO: use modellight for r_ambient settings on world?
7010                         VectorSet(ent->modellight_ambient, 0, 0, 0);
7011                         VectorSet(ent->modellight_diffuse, 0, 0, 0);
7012                         VectorSet(ent->modellight_lightdir, 0, 0, 1);
7013                         continue;
7014                 }
7015
7016                 // fetch the lighting from the worldmodel data
7017                 VectorClear(ent->modellight_ambient);
7018                 VectorClear(ent->modellight_diffuse);
7019                 VectorClear(tempdiffusenormal);
7020                 if ((ent->flags & RENDER_LIGHT) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.LightPoint)
7021                 {
7022                         vec3_t org;
7023                         Matrix4x4_OriginFromMatrix(&ent->matrix, org);
7024                         r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, org, ent->modellight_ambient, ent->modellight_diffuse, tempdiffusenormal);
7025                         if(ent->flags & RENDER_EQUALIZE)
7026                         {
7027                                 // first fix up ambient lighting...
7028                                 if(r_equalize_entities_minambient.value > 0)
7029                                 {
7030                                         fd = 0.299f * ent->modellight_diffuse[0] + 0.587f * ent->modellight_diffuse[1] + 0.114f * ent->modellight_diffuse[2];
7031                                         if(fd > 0)
7032                                         {
7033                                                 fa = (0.299f * ent->modellight_ambient[0] + 0.587f * ent->modellight_ambient[1] + 0.114f * ent->modellight_ambient[2]);
7034                                                 if(fa < r_equalize_entities_minambient.value * fd)
7035                                                 {
7036                                                         // solve:
7037                                                         //   fa'/fd' = minambient
7038                                                         //   fa'+0.25*fd' = fa+0.25*fd
7039                                                         //   ...
7040                                                         //   fa' = fd' * minambient
7041                                                         //   fd'*(0.25+minambient) = fa+0.25*fd
7042                                                         //   ...
7043                                                         //   fd' = (fa+0.25*fd) * 1 / (0.25+minambient)
7044                                                         //   fa' = (fa+0.25*fd) * minambient / (0.25+minambient)
7045                                                         //   ...
7046                                                         fdd = (fa + 0.25f * fd) / (0.25f + r_equalize_entities_minambient.value);
7047                                                         f = fdd / fd; // f>0 because all this is additive; f<1 because fdd<fd because this follows from fa < r_equalize_entities_minambient.value * fd
7048                                                         VectorMA(ent->modellight_ambient, (1-f)*0.25f, ent->modellight_diffuse, ent->modellight_ambient);
7049                                                         VectorScale(ent->modellight_diffuse, f, ent->modellight_diffuse);
7050                                                 }
7051                                         }
7052                                 }
7053
7054                                 if(r_equalize_entities_to.value > 0 && r_equalize_entities_by.value != 0)
7055                                 {
7056                                         VectorMA(ent->modellight_ambient, 0.25f, ent->modellight_diffuse, avg);
7057                                         f = 0.299f * avg[0] + 0.587f * avg[1] + 0.114f * avg[2];
7058                                         if(f > 0)
7059                                         {
7060                                                 f = pow(f / r_equalize_entities_to.value, -r_equalize_entities_by.value);
7061                                                 VectorScale(ent->modellight_ambient, f, ent->modellight_ambient);
7062                                                 VectorScale(ent->modellight_diffuse, f, ent->modellight_diffuse);
7063                                         }
7064                                 }
7065                         }
7066                 }
7067                 else // highly rare
7068                         VectorSet(ent->modellight_ambient, 1, 1, 1);
7069
7070                 // move the light direction into modelspace coordinates for lighting code
7071                 Matrix4x4_Transform3x3(&ent->inversematrix, tempdiffusenormal, ent->modellight_lightdir);
7072                 if(VectorLength2(ent->modellight_lightdir) == 0)
7073                         VectorSet(ent->modellight_lightdir, 0, 0, 1); // have to set SOME valid vector here
7074                 VectorNormalize(ent->modellight_lightdir);
7075         }
7076 }
7077
7078 #define MAX_LINEOFSIGHTTRACES 64
7079
7080 static qboolean R_CanSeeBox(int numsamples, vec_t enlarge, vec3_t eye, vec3_t entboxmins, vec3_t entboxmaxs)
7081 {
7082         int i;
7083         vec3_t boxmins, boxmaxs;
7084         vec3_t start;
7085         vec3_t end;
7086         dp_model_t *model = r_refdef.scene.worldmodel;
7087
7088         if (!model || !model->brush.TraceLineOfSight)
7089                 return true;
7090
7091         // expand the box a little
7092         boxmins[0] = (enlarge+1) * entboxmins[0] - enlarge * entboxmaxs[0];
7093         boxmaxs[0] = (enlarge+1) * entboxmaxs[0] - enlarge * entboxmins[0];
7094         boxmins[1] = (enlarge+1) * entboxmins[1] - enlarge * entboxmaxs[1];
7095         boxmaxs[1] = (enlarge+1) * entboxmaxs[1] - enlarge * entboxmins[1];
7096         boxmins[2] = (enlarge+1) * entboxmins[2] - enlarge * entboxmaxs[2];
7097         boxmaxs[2] = (enlarge+1) * entboxmaxs[2] - enlarge * entboxmins[2];
7098
7099         // return true if eye is inside enlarged box
7100         if (BoxesOverlap(boxmins, boxmaxs, eye, eye))
7101                 return true;
7102
7103         // try center
7104         VectorCopy(eye, start);
7105         VectorMAM(0.5f, boxmins, 0.5f, boxmaxs, end);
7106         if (model->brush.TraceLineOfSight(model, start, end))
7107                 return true;
7108
7109         // try various random positions
7110         for (i = 0;i < numsamples;i++)
7111         {
7112                 VectorSet(end, lhrandom(boxmins[0], boxmaxs[0]), lhrandom(boxmins[1], boxmaxs[1]), lhrandom(boxmins[2], boxmaxs[2]));
7113                 if (model->brush.TraceLineOfSight(model, start, end))
7114                         return true;
7115         }
7116
7117         return false;
7118 }
7119
7120
7121 static void R_View_UpdateEntityVisible (void)
7122 {
7123         int i;
7124         int renderimask;
7125         int samples;
7126         entity_render_t *ent;
7127
7128         renderimask = r_refdef.envmap                                    ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL)
7129                 : r_waterstate.renderingrefraction                       ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL)
7130                 : (chase_active.integer || r_waterstate.renderingscene)  ? RENDER_VIEWMODEL
7131                 :                                                          RENDER_EXTERIORMODEL;
7132         if (!r_drawviewmodel.integer)
7133                 renderimask |= RENDER_VIEWMODEL;
7134         if (!r_drawexteriormodel.integer)
7135                 renderimask |= RENDER_EXTERIORMODEL;
7136         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs)
7137         {
7138                 // worldmodel can check visibility
7139                 memset(r_refdef.viewcache.entityvisible, 0, r_refdef.scene.numentities);
7140                 for (i = 0;i < r_refdef.scene.numentities;i++)
7141                 {
7142                         ent = r_refdef.scene.entities[i];
7143                         if (!(ent->flags & renderimask))
7144                         if (!R_CullBox(ent->mins, ent->maxs) || (ent->model && ent->model->type == mod_sprite && (ent->model->sprite.sprnum_type == SPR_LABEL || ent->model->sprite.sprnum_type == SPR_LABEL_SCALE)))
7145                         if ((ent->flags & (RENDER_NODEPTHTEST | RENDER_VIEWMODEL)) || r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.scene.worldmodel, r_refdef.viewcache.world_leafvisible, ent->mins, ent->maxs))
7146                                 r_refdef.viewcache.entityvisible[i] = true;
7147                 }
7148                 if(r_cullentities_trace.integer && r_refdef.scene.worldmodel->brush.TraceLineOfSight && !r_refdef.view.useclipplane)
7149                         // sorry, this check doesn't work for portal/reflection/refraction renders as the view origin is not useful for culling
7150                 {
7151                         for (i = 0;i < r_refdef.scene.numentities;i++)
7152                         {
7153                                 ent = r_refdef.scene.entities[i];
7154                                 if(r_refdef.viewcache.entityvisible[i] && !(ent->flags & (RENDER_VIEWMODEL | RENDER_NOCULL | RENDER_NODEPTHTEST)) && !(ent->model && (ent->model->name[0] == '*')))
7155                                 {
7156                                         samples = ent->entitynumber ? r_cullentities_trace_samples.integer : r_cullentities_trace_tempentitysamples.integer;
7157                                         if (samples < 0)
7158                                                 continue; // temp entities do pvs only
7159                                         if(R_CanSeeBox(samples, r_cullentities_trace_enlarge.value, r_refdef.view.origin, ent->mins, ent->maxs))
7160                                                 ent->last_trace_visibility = realtime;
7161                                         if(ent->last_trace_visibility < realtime - r_cullentities_trace_delay.value)
7162                                                 r_refdef.viewcache.entityvisible[i] = 0;
7163                                 }
7164                         }
7165                 }
7166         }
7167         else
7168         {
7169                 // no worldmodel or it can't check visibility
7170                 for (i = 0;i < r_refdef.scene.numentities;i++)
7171                 {
7172                         ent = r_refdef.scene.entities[i];
7173                         r_refdef.viewcache.entityvisible[i] = !(ent->flags & renderimask) && ((ent->model && ent->model->type == mod_sprite && (ent->model->sprite.sprnum_type == SPR_LABEL || ent->model->sprite.sprnum_type == SPR_LABEL_SCALE)) || !R_CullBox(ent->mins, ent->maxs));
7174                 }
7175         }
7176 }
7177
7178 /// only used if skyrendermasked, and normally returns false
7179 int R_DrawBrushModelsSky (void)
7180 {
7181         int i, sky;
7182         entity_render_t *ent;
7183
7184         sky = false;
7185         for (i = 0;i < r_refdef.scene.numentities;i++)
7186         {
7187                 if (!r_refdef.viewcache.entityvisible[i])
7188                         continue;
7189                 ent = r_refdef.scene.entities[i];
7190                 if (!ent->model || !ent->model->DrawSky)
7191                         continue;
7192                 ent->model->DrawSky(ent);
7193                 sky = true;
7194         }
7195         return sky;
7196 }
7197
7198 static void R_DrawNoModel(entity_render_t *ent);
7199 static void R_DrawModels(void)
7200 {
7201         int i;
7202         entity_render_t *ent;
7203
7204         for (i = 0;i < r_refdef.scene.numentities;i++)
7205         {
7206                 if (!r_refdef.viewcache.entityvisible[i])
7207                         continue;
7208                 ent = r_refdef.scene.entities[i];
7209                 r_refdef.stats.entities++;
7210                 if (ent->model && ent->model->Draw != NULL)
7211                         ent->model->Draw(ent);
7212                 else
7213                         R_DrawNoModel(ent);
7214         }
7215 }
7216
7217 static void R_DrawModelsDepth(void)
7218 {
7219         int i;
7220         entity_render_t *ent;
7221
7222         for (i = 0;i < r_refdef.scene.numentities;i++)
7223         {
7224                 if (!r_refdef.viewcache.entityvisible[i])
7225                         continue;
7226                 ent = r_refdef.scene.entities[i];
7227                 if (ent->model && ent->model->DrawDepth != NULL)
7228                         ent->model->DrawDepth(ent);
7229         }
7230 }
7231
7232 static void R_DrawModelsDebug(void)
7233 {
7234         int i;
7235         entity_render_t *ent;
7236
7237         for (i = 0;i < r_refdef.scene.numentities;i++)
7238         {
7239                 if (!r_refdef.viewcache.entityvisible[i])
7240                         continue;
7241                 ent = r_refdef.scene.entities[i];
7242                 if (ent->model && ent->model->DrawDebug != NULL)
7243                         ent->model->DrawDebug(ent);
7244         }
7245 }
7246
7247 static void R_DrawModelsAddWaterPlanes(void)
7248 {
7249         int i;
7250         entity_render_t *ent;
7251
7252         for (i = 0;i < r_refdef.scene.numentities;i++)
7253         {
7254                 if (!r_refdef.viewcache.entityvisible[i])
7255                         continue;
7256                 ent = r_refdef.scene.entities[i];
7257                 if (ent->model && ent->model->DrawAddWaterPlanes != NULL)
7258                         ent->model->DrawAddWaterPlanes(ent);
7259         }
7260 }
7261
7262 static void R_View_SetFrustum(void)
7263 {
7264         int i;
7265         double slopex, slopey;
7266         vec3_t forward, left, up, origin;
7267
7268         // we can't trust r_refdef.view.forward and friends in reflected scenes
7269         Matrix4x4_ToVectors(&r_refdef.view.matrix, forward, left, up, origin);
7270
7271 #if 0
7272         r_refdef.view.frustum[0].normal[0] = 0 - 1.0 / r_refdef.view.frustum_x;
7273         r_refdef.view.frustum[0].normal[1] = 0 - 0;
7274         r_refdef.view.frustum[0].normal[2] = -1 - 0;
7275         r_refdef.view.frustum[1].normal[0] = 0 + 1.0 / r_refdef.view.frustum_x;
7276         r_refdef.view.frustum[1].normal[1] = 0 + 0;
7277         r_refdef.view.frustum[1].normal[2] = -1 + 0;
7278         r_refdef.view.frustum[2].normal[0] = 0 - 0;
7279         r_refdef.view.frustum[2].normal[1] = 0 - 1.0 / r_refdef.view.frustum_y;
7280         r_refdef.view.frustum[2].normal[2] = -1 - 0;
7281         r_refdef.view.frustum[3].normal[0] = 0 + 0;
7282         r_refdef.view.frustum[3].normal[1] = 0 + 1.0 / r_refdef.view.frustum_y;
7283         r_refdef.view.frustum[3].normal[2] = -1 + 0;
7284 #endif
7285
7286 #if 0
7287         zNear = r_refdef.nearclip;
7288         nudge = 1.0 - 1.0 / (1<<23);
7289         r_refdef.view.frustum[4].normal[0] = 0 - 0;
7290         r_refdef.view.frustum[4].normal[1] = 0 - 0;
7291         r_refdef.view.frustum[4].normal[2] = -1 - -nudge;
7292         r_refdef.view.frustum[4].dist = 0 - -2 * zNear * nudge;
7293         r_refdef.view.frustum[5].normal[0] = 0 + 0;
7294         r_refdef.view.frustum[5].normal[1] = 0 + 0;
7295         r_refdef.view.frustum[5].normal[2] = -1 + -nudge;
7296         r_refdef.view.frustum[5].dist = 0 + -2 * zNear * nudge;
7297 #endif
7298
7299
7300
7301 #if 0
7302         r_refdef.view.frustum[0].normal[0] = m[3] - m[0];
7303         r_refdef.view.frustum[0].normal[1] = m[7] - m[4];
7304         r_refdef.view.frustum[0].normal[2] = m[11] - m[8];
7305         r_refdef.view.frustum[0].dist = m[15] - m[12];
7306
7307         r_refdef.view.frustum[1].normal[0] = m[3] + m[0];
7308         r_refdef.view.frustum[1].normal[1] = m[7] + m[4];
7309         r_refdef.view.frustum[1].normal[2] = m[11] + m[8];
7310         r_refdef.view.frustum[1].dist = m[15] + m[12];
7311
7312         r_refdef.view.frustum[2].normal[0] = m[3] - m[1];
7313         r_refdef.view.frustum[2].normal[1] = m[7] - m[5];
7314         r_refdef.view.frustum[2].normal[2] = m[11] - m[9];
7315         r_refdef.view.frustum[2].dist = m[15] - m[13];
7316
7317         r_refdef.view.frustum[3].normal[0] = m[3] + m[1];
7318         r_refdef.view.frustum[3].normal[1] = m[7] + m[5];
7319         r_refdef.view.frustum[3].normal[2] = m[11] + m[9];
7320         r_refdef.view.frustum[3].dist = m[15] + m[13];
7321
7322         r_refdef.view.frustum[4].normal[0] = m[3] - m[2];
7323         r_refdef.view.frustum[4].normal[1] = m[7] - m[6];
7324         r_refdef.view.frustum[4].normal[2] = m[11] - m[10];
7325         r_refdef.view.frustum[4].dist = m[15] - m[14];
7326
7327         r_refdef.view.frustum[5].normal[0] = m[3] + m[2];
7328         r_refdef.view.frustum[5].normal[1] = m[7] + m[6];
7329         r_refdef.view.frustum[5].normal[2] = m[11] + m[10];
7330         r_refdef.view.frustum[5].dist = m[15] + m[14];
7331 #endif
7332
7333         if (r_refdef.view.useperspective)
7334         {
7335                 slopex = 1.0 / r_refdef.view.frustum_x;
7336                 slopey = 1.0 / r_refdef.view.frustum_y;
7337                 VectorMA(forward, -slopex, left, r_refdef.view.frustum[0].normal);
7338                 VectorMA(forward,  slopex, left, r_refdef.view.frustum[1].normal);
7339                 VectorMA(forward, -slopey, up  , r_refdef.view.frustum[2].normal);
7340                 VectorMA(forward,  slopey, up  , r_refdef.view.frustum[3].normal);
7341                 VectorCopy(forward, r_refdef.view.frustum[4].normal);
7342
7343                 // Leaving those out was a mistake, those were in the old code, and they
7344                 // fix a reproducable bug in this one: frustum culling got fucked up when viewmatrix was an identity matrix
7345                 // I couldn't reproduce it after adding those normalizations. --blub
7346                 VectorNormalize(r_refdef.view.frustum[0].normal);
7347                 VectorNormalize(r_refdef.view.frustum[1].normal);
7348                 VectorNormalize(r_refdef.view.frustum[2].normal);
7349                 VectorNormalize(r_refdef.view.frustum[3].normal);
7350
7351                 // calculate frustum corners, which are used to calculate deformed frustum planes for shadow caster culling
7352                 VectorMAMAMAM(1, r_refdef.view.origin, 1024, forward, -1024 * r_refdef.view.frustum_x, left, -1024 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[0]);
7353                 VectorMAMAMAM(1, r_refdef.view.origin, 1024, forward,  1024 * r_refdef.view.frustum_x, left, -1024 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[1]);
7354                 VectorMAMAMAM(1, r_refdef.view.origin, 1024, forward, -1024 * r_refdef.view.frustum_x, left,  1024 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[2]);
7355                 VectorMAMAMAM(1, r_refdef.view.origin, 1024, forward,  1024 * r_refdef.view.frustum_x, left,  1024 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[3]);
7356
7357                 r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[0].normal);
7358                 r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[1].normal);
7359                 r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[2].normal);
7360                 r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[3].normal);
7361                 r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[4].normal) + r_refdef.nearclip;
7362         }
7363         else
7364         {
7365                 VectorScale(left, -r_refdef.view.ortho_x, r_refdef.view.frustum[0].normal);
7366                 VectorScale(left,  r_refdef.view.ortho_x, r_refdef.view.frustum[1].normal);
7367                 VectorScale(up, -r_refdef.view.ortho_y, r_refdef.view.frustum[2].normal);
7368                 VectorScale(up,  r_refdef.view.ortho_y, r_refdef.view.frustum[3].normal);
7369                 VectorCopy(forward, r_refdef.view.frustum[4].normal);
7370                 r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[0].normal) + r_refdef.view.ortho_x;
7371                 r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[1].normal) + r_refdef.view.ortho_x;
7372                 r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[2].normal) + r_refdef.view.ortho_y;
7373                 r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[3].normal) + r_refdef.view.ortho_y;
7374                 r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[4].normal) + r_refdef.nearclip;
7375         }
7376         r_refdef.view.numfrustumplanes = 5;
7377
7378         if (r_refdef.view.useclipplane)
7379         {
7380                 r_refdef.view.numfrustumplanes = 6;
7381                 r_refdef.view.frustum[5] = r_refdef.view.clipplane;
7382         }
7383
7384         for (i = 0;i < r_refdef.view.numfrustumplanes;i++)
7385                 PlaneClassify(r_refdef.view.frustum + i);
7386
7387         // LordHavoc: note to all quake engine coders, Quake had a special case
7388         // for 90 degrees which assumed a square view (wrong), so I removed it,
7389         // Quake2 has it disabled as well.
7390
7391         // rotate R_VIEWFORWARD right by FOV_X/2 degrees
7392         //RotatePointAroundVector( r_refdef.view.frustum[0].normal, up, forward, -(90 - r_refdef.fov_x / 2));
7393         //r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, frustum[0].normal);
7394         //PlaneClassify(&frustum[0]);
7395
7396         // rotate R_VIEWFORWARD left by FOV_X/2 degrees
7397         //RotatePointAroundVector( r_refdef.view.frustum[1].normal, up, forward, (90 - r_refdef.fov_x / 2));
7398         //r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, frustum[1].normal);
7399         //PlaneClassify(&frustum[1]);
7400
7401         // rotate R_VIEWFORWARD up by FOV_X/2 degrees
7402         //RotatePointAroundVector( r_refdef.view.frustum[2].normal, left, forward, -(90 - r_refdef.fov_y / 2));
7403         //r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, frustum[2].normal);
7404         //PlaneClassify(&frustum[2]);
7405
7406         // rotate R_VIEWFORWARD down by FOV_X/2 degrees
7407         //RotatePointAroundVector( r_refdef.view.frustum[3].normal, left, forward, (90 - r_refdef.fov_y / 2));
7408         //r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, frustum[3].normal);
7409         //PlaneClassify(&frustum[3]);
7410
7411         // nearclip plane
7412         //VectorCopy(forward, r_refdef.view.frustum[4].normal);
7413         //r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, frustum[4].normal) + r_nearclip.value;
7414         //PlaneClassify(&frustum[4]);
7415 }
7416
7417 void R_View_Update(void)
7418 {
7419         R_Main_ResizeViewCache();
7420         R_View_SetFrustum();
7421         R_View_WorldVisibility(r_refdef.view.useclipplane);
7422         R_View_UpdateEntityVisible();
7423         R_View_UpdateEntityLighting();
7424 }
7425
7426 void R_SetupView(qboolean allowwaterclippingplane)
7427 {
7428         const float *customclipplane = NULL;
7429         float plane[4];
7430         if (r_refdef.view.useclipplane && allowwaterclippingplane)
7431         {
7432                 // LordHavoc: couldn't figure out how to make this approach the
7433                 vec_t dist = r_refdef.view.clipplane.dist - r_water_clippingplanebias.value;
7434                 vec_t viewdist = DotProduct(r_refdef.view.origin, r_refdef.view.clipplane.normal);
7435                 if (viewdist < r_refdef.view.clipplane.dist + r_water_clippingplanebias.value)
7436                         dist = r_refdef.view.clipplane.dist;
7437                 plane[0] = r_refdef.view.clipplane.normal[0];
7438                 plane[1] = r_refdef.view.clipplane.normal[1];
7439                 plane[2] = r_refdef.view.clipplane.normal[2];
7440                 plane[3] = dist;
7441                 customclipplane = plane;
7442         }
7443
7444         if (!r_refdef.view.useperspective)
7445                 R_Viewport_InitOrtho(&r_refdef.view.viewport, &r_refdef.view.matrix, r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height, -r_refdef.view.ortho_x, -r_refdef.view.ortho_y, r_refdef.view.ortho_x, r_refdef.view.ortho_y, -r_refdef.farclip, r_refdef.farclip, customclipplane);
7446         else if (vid.stencil && r_useinfinitefarclip.integer)
7447                 R_Viewport_InitPerspectiveInfinite(&r_refdef.view.viewport, &r_refdef.view.matrix, r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height, r_refdef.view.frustum_x, r_refdef.view.frustum_y, r_refdef.nearclip, customclipplane);
7448         else
7449                 R_Viewport_InitPerspective(&r_refdef.view.viewport, &r_refdef.view.matrix, r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height, r_refdef.view.frustum_x, r_refdef.view.frustum_y, r_refdef.nearclip, r_refdef.farclip, customclipplane);
7450         R_SetViewport(&r_refdef.view.viewport);
7451 }
7452
7453 void R_EntityMatrix(const matrix4x4_t *matrix)
7454 {
7455         if (gl_modelmatrixchanged || memcmp(matrix, &gl_modelmatrix, sizeof(matrix4x4_t)))
7456         {
7457                 gl_modelmatrixchanged = false;
7458                 gl_modelmatrix = *matrix;
7459                 Matrix4x4_Concat(&gl_modelviewmatrix, &gl_viewmatrix, &gl_modelmatrix);
7460                 Matrix4x4_Concat(&gl_modelviewprojectionmatrix, &gl_projectionmatrix, &gl_modelviewmatrix);
7461                 Matrix4x4_ToArrayFloatGL(&gl_modelviewmatrix, gl_modelview16f);
7462                 Matrix4x4_ToArrayFloatGL(&gl_modelviewprojectionmatrix, gl_modelviewprojection16f);
7463                 CHECKGLERROR
7464                 switch(vid.renderpath)
7465                 {
7466                 case RENDERPATH_GL20:
7467                         if (r_glsl_permutation && r_glsl_permutation->loc_ModelViewProjectionMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewProjectionMatrix, 1, false, gl_modelviewprojection16f);
7468                         if (r_glsl_permutation && r_glsl_permutation->loc_ModelViewMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewMatrix, 1, false, gl_modelview16f);
7469                         qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
7470                         break;
7471                 case RENDERPATH_CGGL:
7472 #ifdef SUPPORTCG
7473                         CHECKCGERROR
7474                         if (r_cg_permutation && r_cg_permutation->vp_ModelViewProjectionMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewProjectionMatrix, gl_modelviewprojection16f);CHECKCGERROR
7475                         if (r_cg_permutation && r_cg_permutation->vp_ModelViewMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewMatrix, gl_modelview16f);CHECKCGERROR
7476                         qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
7477 #endif
7478                         break;
7479                 case RENDERPATH_GL13:
7480                 case RENDERPATH_GL11:
7481                         qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
7482                         break;
7483                 }
7484         }
7485 }
7486
7487 void R_ResetViewRendering2D(void)
7488 {
7489         r_viewport_t viewport;
7490         DrawQ_Finish();
7491
7492         // GL is weird because it's bottom to top, r_refdef.view.y is top to bottom
7493         R_Viewport_InitOrtho(&viewport, &identitymatrix, r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height, 0, 0, 1, 1, -10, 100, NULL);
7494         R_SetViewport(&viewport);
7495         GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
7496         GL_Color(1, 1, 1, 1);
7497         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
7498         GL_BlendFunc(GL_ONE, GL_ZERO);
7499         GL_AlphaTest(false);
7500         GL_ScissorTest(false);
7501         GL_DepthMask(false);
7502         GL_DepthRange(0, 1);
7503         GL_DepthTest(false);
7504         R_EntityMatrix(&identitymatrix);
7505         R_Mesh_ResetTextureState();
7506         GL_PolygonOffset(0, 0);
7507         qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
7508         qglDepthFunc(GL_LEQUAL);CHECKGLERROR
7509         qglDisable(GL_STENCIL_TEST);CHECKGLERROR
7510         qglStencilMask(~0);CHECKGLERROR
7511         qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
7512         qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
7513         GL_CullFace(GL_FRONT); // quake is backwards, this culls back faces
7514 }
7515
7516 void R_ResetViewRendering3D(void)
7517 {
7518         DrawQ_Finish();
7519
7520         R_SetupView(true);
7521         GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
7522         GL_Color(1, 1, 1, 1);
7523         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
7524         GL_BlendFunc(GL_ONE, GL_ZERO);
7525         GL_AlphaTest(false);
7526         GL_ScissorTest(true);
7527         GL_DepthMask(true);
7528         GL_DepthRange(0, 1);
7529         GL_DepthTest(true);
7530         R_EntityMatrix(&identitymatrix);
7531         R_Mesh_ResetTextureState();
7532         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
7533         qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
7534         qglDepthFunc(GL_LEQUAL);CHECKGLERROR
7535         qglDisable(GL_STENCIL_TEST);CHECKGLERROR
7536         qglStencilMask(~0);CHECKGLERROR
7537         qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
7538         qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
7539         GL_CullFace(r_refdef.view.cullface_back);
7540 }
7541
7542 /*
7543 ================
7544 R_RenderView_UpdateViewVectors
7545 ================
7546 */
7547 static void R_RenderView_UpdateViewVectors(void)
7548 {
7549         // break apart the view matrix into vectors for various purposes
7550         // it is important that this occurs outside the RenderScene function because that can be called from reflection renders, where the vectors come out wrong
7551         // however the r_refdef.view.origin IS updated in RenderScene intentionally - otherwise the sky renders at the wrong origin, etc
7552         Matrix4x4_ToVectors(&r_refdef.view.matrix, r_refdef.view.forward, r_refdef.view.left, r_refdef.view.up, r_refdef.view.origin);
7553         VectorNegate(r_refdef.view.left, r_refdef.view.right);
7554         // make an inverted copy of the view matrix for tracking sprites
7555         Matrix4x4_Invert_Simple(&r_refdef.view.inverse_matrix, &r_refdef.view.matrix);
7556 }
7557
7558 void R_RenderScene(void);
7559 void R_RenderWaterPlanes(void);
7560
7561 static void R_Water_StartFrame(void)
7562 {
7563         int i;
7564         int waterwidth, waterheight, texturewidth, textureheight, camerawidth, cameraheight;
7565         r_waterstate_waterplane_t *p;
7566
7567         if (vid.width > (int)vid.maxtexturesize_2d || vid.height > (int)vid.maxtexturesize_2d)
7568                 return;
7569
7570         switch(vid.renderpath)
7571         {
7572         case RENDERPATH_GL20:
7573         case RENDERPATH_CGGL:
7574                 break;
7575         case RENDERPATH_GL13:
7576         case RENDERPATH_GL11:
7577                 return;
7578         }
7579
7580         // set waterwidth and waterheight to the water resolution that will be
7581         // used (often less than the screen resolution for faster rendering)
7582         waterwidth = (int)bound(1, vid.width * r_water_resolutionmultiplier.value, vid.width);
7583         waterheight = (int)bound(1, vid.height * r_water_resolutionmultiplier.value, vid.height);
7584
7585         // calculate desired texture sizes
7586         // can't use water if the card does not support the texture size
7587         if (!r_water.integer || r_showsurfaces.integer)
7588                 texturewidth = textureheight = waterwidth = waterheight = camerawidth = cameraheight = 0;
7589         else if (vid.support.arb_texture_non_power_of_two)
7590         {
7591                 texturewidth = waterwidth;
7592                 textureheight = waterheight;
7593                 camerawidth = waterwidth;
7594                 cameraheight = waterheight;
7595         }
7596         else
7597         {
7598                 for (texturewidth   = 1;texturewidth   < waterwidth ;texturewidth   *= 2);
7599                 for (textureheight  = 1;textureheight  < waterheight;textureheight  *= 2);
7600                 for (camerawidth    = 1;camerawidth   <= waterwidth; camerawidth    *= 2); camerawidth  /= 2;
7601                 for (cameraheight   = 1;cameraheight  <= waterheight;cameraheight   *= 2); cameraheight /= 2;
7602         }
7603
7604         // allocate textures as needed
7605         if (r_waterstate.texturewidth != texturewidth || r_waterstate.textureheight != textureheight || r_waterstate.camerawidth != camerawidth || r_waterstate.cameraheight != cameraheight)
7606         {
7607                 r_waterstate.maxwaterplanes = MAX_WATERPLANES;
7608                 for (i = 0, p = r_waterstate.waterplanes;i < r_waterstate.maxwaterplanes;i++, p++)
7609                 {
7610                         if (p->texture_refraction)
7611                                 R_FreeTexture(p->texture_refraction);
7612                         p->texture_refraction = NULL;
7613                         if (p->texture_reflection)
7614                                 R_FreeTexture(p->texture_reflection);
7615                         p->texture_reflection = NULL;
7616                         if (p->texture_camera)
7617                                 R_FreeTexture(p->texture_camera);
7618                         p->texture_camera = NULL;
7619                 }
7620                 memset(&r_waterstate, 0, sizeof(r_waterstate));
7621                 r_waterstate.texturewidth = texturewidth;
7622                 r_waterstate.textureheight = textureheight;
7623                 r_waterstate.camerawidth = camerawidth;
7624                 r_waterstate.cameraheight = cameraheight;
7625         }
7626
7627         if (r_waterstate.texturewidth)
7628         {
7629                 r_waterstate.enabled = true;
7630
7631                 // when doing a reduced render (HDR) we want to use a smaller area
7632                 r_waterstate.waterwidth = (int)bound(1, r_refdef.view.width * r_water_resolutionmultiplier.value, r_refdef.view.width);
7633                 r_waterstate.waterheight = (int)bound(1, r_refdef.view.height * r_water_resolutionmultiplier.value, r_refdef.view.height);
7634
7635                 // set up variables that will be used in shader setup
7636                 r_waterstate.screenscale[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
7637                 r_waterstate.screenscale[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
7638                 r_waterstate.screencenter[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
7639                 r_waterstate.screencenter[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
7640         }
7641
7642         r_waterstate.maxwaterplanes = MAX_WATERPLANES;
7643         r_waterstate.numwaterplanes = 0;
7644 }
7645
7646 void R_Water_AddWaterPlane(msurface_t *surface)
7647 {
7648         int triangleindex, planeindex;
7649         const int *e;
7650         vec3_t vert[3];
7651         vec3_t normal;
7652         vec3_t center;
7653         mplane_t plane;
7654         int cam_ent;
7655         r_waterstate_waterplane_t *p;
7656         texture_t *t = R_GetCurrentTexture(surface->texture);
7657         cam_ent = t->camera_entity;
7658         if(!(t->currentmaterialflags & MATERIALFLAG_CAMERA))
7659                 cam_ent = 0;
7660
7661         // just use the first triangle with a valid normal for any decisions
7662         VectorClear(normal);
7663         for (triangleindex = 0, e = rsurface.modelelement3i + surface->num_firsttriangle * 3;triangleindex < surface->num_triangles;triangleindex++, e += 3)
7664         {
7665                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[0]*3, vert[0]);
7666                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[1]*3, vert[1]);
7667                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[2]*3, vert[2]);
7668                 TriangleNormal(vert[0], vert[1], vert[2], normal);
7669                 if (VectorLength2(normal) >= 0.001)
7670                         break;
7671         }
7672
7673         VectorCopy(normal, plane.normal);
7674         VectorNormalize(plane.normal);
7675         plane.dist = DotProduct(vert[0], plane.normal);
7676         PlaneClassify(&plane);
7677         if (PlaneDiff(r_refdef.view.origin, &plane) < 0)
7678         {
7679                 // skip backfaces (except if nocullface is set)
7680                 if (!(t->currentmaterialflags & MATERIALFLAG_NOCULLFACE))
7681                         return;
7682                 VectorNegate(plane.normal, plane.normal);
7683                 plane.dist *= -1;
7684                 PlaneClassify(&plane);
7685         }
7686
7687
7688         // find a matching plane if there is one
7689         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
7690                 if(p->camera_entity == t->camera_entity)
7691                         if (fabs(PlaneDiff(vert[0], &p->plane)) < 1 && fabs(PlaneDiff(vert[1], &p->plane)) < 1 && fabs(PlaneDiff(vert[2], &p->plane)) < 1)
7692                                 break;
7693         if (planeindex >= r_waterstate.maxwaterplanes)
7694                 return; // nothing we can do, out of planes
7695
7696         // if this triangle does not fit any known plane rendered this frame, add one
7697         if (planeindex >= r_waterstate.numwaterplanes)
7698         {
7699                 // store the new plane
7700                 r_waterstate.numwaterplanes++;
7701                 p->plane = plane;
7702                 // clear materialflags and pvs
7703                 p->materialflags = 0;
7704                 p->pvsvalid = false;
7705                 p->camera_entity = t->camera_entity;
7706         }
7707         // merge this surface's materialflags into the waterplane
7708         p->materialflags |= t->currentmaterialflags;
7709         if(!(p->materialflags & MATERIALFLAG_CAMERA))
7710         {
7711                 // merge this surface's PVS into the waterplane
7712                 VectorMAM(0.5f, surface->mins, 0.5f, surface->maxs, center);
7713                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS
7714                  && r_refdef.scene.worldmodel->brush.PointInLeaf && r_refdef.scene.worldmodel->brush.PointInLeaf(r_refdef.scene.worldmodel, center)->clusterindex >= 0)
7715                 {
7716                         r_refdef.scene.worldmodel->brush.FatPVS(r_refdef.scene.worldmodel, center, 2, p->pvsbits, sizeof(p->pvsbits), p->pvsvalid);
7717                         p->pvsvalid = true;
7718                 }
7719         }
7720 }
7721
7722 static void R_Water_ProcessPlanes(void)
7723 {
7724         r_refdef_view_t originalview;
7725         r_refdef_view_t myview;
7726         int planeindex;
7727         r_waterstate_waterplane_t *p;
7728         vec3_t visorigin;
7729
7730         originalview = r_refdef.view;
7731
7732         // make sure enough textures are allocated
7733         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
7734         {
7735                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
7736                 {
7737                         if (!p->texture_refraction)
7738                                 p->texture_refraction = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_refraction", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
7739                         if (!p->texture_refraction)
7740                                 goto error;
7741                 }
7742                 else if (p->materialflags & MATERIALFLAG_CAMERA)
7743                 {
7744                         if (!p->texture_camera)
7745                                 p->texture_camera = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_camera", planeindex), r_waterstate.camerawidth, r_waterstate.cameraheight, NULL, TEXTYPE_COLORBUFFER, TEXF_FORCELINEAR, -1, NULL);
7746                         if (!p->texture_camera)
7747                                 goto error;
7748                 }
7749
7750                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
7751                 {
7752                         if (!p->texture_reflection)
7753                                 p->texture_reflection = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_reflection", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
7754                         if (!p->texture_reflection)
7755                                 goto error;
7756                 }
7757         }
7758
7759         // render views
7760         r_refdef.view = originalview;
7761         r_refdef.view.showdebug = false;
7762         r_refdef.view.width = r_waterstate.waterwidth;
7763         r_refdef.view.height = r_waterstate.waterheight;
7764         r_refdef.view.useclipplane = true;
7765         myview = r_refdef.view;
7766         r_waterstate.renderingscene = true;
7767         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
7768         {
7769                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
7770                 {
7771                         r_refdef.view = myview;
7772                         // render reflected scene and copy into texture
7773                         Matrix4x4_Reflect(&r_refdef.view.matrix, p->plane.normal[0], p->plane.normal[1], p->plane.normal[2], p->plane.dist, -2);
7774                         // update the r_refdef.view.origin because otherwise the sky renders at the wrong location (amongst other problems)
7775                         Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, r_refdef.view.origin);
7776                         r_refdef.view.clipplane = p->plane;
7777                         // reverse the cullface settings for this render
7778                         r_refdef.view.cullface_front = GL_FRONT;
7779                         r_refdef.view.cullface_back = GL_BACK;
7780                         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.num_pvsclusterbytes)
7781                         {
7782                                 r_refdef.view.usecustompvs = true;
7783                                 if (p->pvsvalid)
7784                                         memcpy(r_refdef.viewcache.world_pvsbits, p->pvsbits, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
7785                                 else
7786                                         memset(r_refdef.viewcache.world_pvsbits, 0xFF, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
7787                         }
7788
7789                         R_ResetViewRendering3D();
7790                         R_ClearScreen(r_refdef.fogenabled);
7791                         R_View_Update();
7792                         R_RenderScene();
7793
7794                         R_Mesh_CopyToTexture(p->texture_reflection, 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
7795                 }
7796
7797                 // render the normal view scene and copy into texture
7798                 // (except that a clipping plane should be used to hide everything on one side of the water, and the viewer's weapon model should be omitted)
7799                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
7800                 {
7801                         r_waterstate.renderingrefraction = true;
7802                         r_refdef.view = myview;
7803
7804                         r_refdef.view.clipplane = p->plane;
7805                         VectorNegate(r_refdef.view.clipplane.normal, r_refdef.view.clipplane.normal);
7806                         r_refdef.view.clipplane.dist = -r_refdef.view.clipplane.dist;
7807
7808                         if((p->materialflags & MATERIALFLAG_CAMERA) && p->camera_entity)
7809                         {
7810                                 // we need to perform a matrix transform to render the view... so let's get the transformation matrix
7811                                 r_waterstate.renderingrefraction = false; // we don't want to hide the player model from these ones
7812                                 CL_VM_TransformView(p->camera_entity - MAX_EDICTS, &r_refdef.view.matrix, &r_refdef.view.clipplane, visorigin);
7813                                 R_RenderView_UpdateViewVectors();
7814                                 if(r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS)
7815                                 {
7816                                         r_refdef.view.usecustompvs = true;
7817                                         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);
7818                                 }
7819                         }
7820
7821                         PlaneClassify(&r_refdef.view.clipplane);
7822
7823                         R_ResetViewRendering3D();
7824                         R_ClearScreen(r_refdef.fogenabled);
7825                         R_View_Update();
7826                         R_RenderScene();
7827
7828                         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);
7829                         r_waterstate.renderingrefraction = false;
7830                 }
7831                 else if (p->materialflags & MATERIALFLAG_CAMERA)
7832                 {
7833                         r_refdef.view = myview;
7834
7835                         r_refdef.view.clipplane = p->plane;
7836                         VectorNegate(r_refdef.view.clipplane.normal, r_refdef.view.clipplane.normal);
7837                         r_refdef.view.clipplane.dist = -r_refdef.view.clipplane.dist;
7838
7839                         r_refdef.view.width = r_waterstate.camerawidth;
7840                         r_refdef.view.height = r_waterstate.cameraheight;
7841                         r_refdef.view.frustum_x = 1; // tan(45 * M_PI / 180.0);
7842                         r_refdef.view.frustum_y = 1; // tan(45 * M_PI / 180.0);
7843
7844                         if(p->camera_entity)
7845                         {
7846                                 // we need to perform a matrix transform to render the view... so let's get the transformation matrix
7847                                 CL_VM_TransformView(p->camera_entity - MAX_EDICTS, &r_refdef.view.matrix, &r_refdef.view.clipplane, visorigin);
7848                         }
7849
7850                         // reverse the cullface settings for this render
7851                         r_refdef.view.cullface_front = GL_FRONT;
7852                         r_refdef.view.cullface_back = GL_BACK;
7853                         // also reverse the view matrix
7854                         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
7855                         R_RenderView_UpdateViewVectors();
7856                         if(p->camera_entity && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS)
7857                         {
7858                                 r_refdef.view.usecustompvs = true;
7859                                 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);
7860                         }
7861
7862                         // camera needs no clipplane
7863                         r_refdef.view.useclipplane = false;
7864
7865                         PlaneClassify(&r_refdef.view.clipplane);
7866
7867                         R_ResetViewRendering3D();
7868                         R_ClearScreen(r_refdef.fogenabled);
7869                         R_View_Update();
7870                         R_RenderScene();
7871
7872                         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);
7873                         r_waterstate.renderingrefraction = false;
7874                 }
7875
7876         }
7877         r_waterstate.renderingscene = false;
7878         r_refdef.view = originalview;
7879         R_ResetViewRendering3D();
7880         R_ClearScreen(r_refdef.fogenabled);
7881         R_View_Update();
7882         return;
7883 error:
7884         r_refdef.view = originalview;
7885         r_waterstate.renderingscene = false;
7886         Cvar_SetValueQuick(&r_water, 0);
7887         Con_Printf("R_Water_ProcessPlanes: Error: texture creation failed!  Turned off r_water.\n");
7888         return;
7889 }
7890
7891 void R_Bloom_StartFrame(void)
7892 {
7893         int bloomtexturewidth, bloomtextureheight, screentexturewidth, screentextureheight;
7894
7895         switch(vid.renderpath)
7896         {
7897         case RENDERPATH_GL20:
7898         case RENDERPATH_CGGL:
7899                 break;
7900         case RENDERPATH_GL13:
7901         case RENDERPATH_GL11:
7902                 return;
7903         }
7904
7905         // set bloomwidth and bloomheight to the bloom resolution that will be
7906         // used (often less than the screen resolution for faster rendering)
7907         r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, vid.height);
7908         r_bloomstate.bloomheight = r_bloomstate.bloomwidth * vid.height / vid.width;
7909         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, vid.height);
7910         r_bloomstate.bloomwidth = bound(1, r_bloomstate.bloomwidth, (int)vid.maxtexturesize_2d);
7911         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, (int)vid.maxtexturesize_2d);
7912
7913         // calculate desired texture sizes
7914         if (vid.support.arb_texture_non_power_of_two)
7915         {
7916                 screentexturewidth = r_refdef.view.width;
7917                 screentextureheight = r_refdef.view.height;
7918                 bloomtexturewidth = r_bloomstate.bloomwidth;
7919                 bloomtextureheight = r_bloomstate.bloomheight;
7920         }
7921         else
7922         {
7923                 for (screentexturewidth  = 1;screentexturewidth  < vid.width               ;screentexturewidth  *= 2);
7924                 for (screentextureheight = 1;screentextureheight < vid.height              ;screentextureheight *= 2);
7925                 for (bloomtexturewidth   = 1;bloomtexturewidth   < r_bloomstate.bloomwidth ;bloomtexturewidth   *= 2);
7926                 for (bloomtextureheight  = 1;bloomtextureheight  < r_bloomstate.bloomheight;bloomtextureheight  *= 2);
7927         }
7928
7929         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))
7930         {
7931                 Cvar_SetValueQuick(&r_hdr, 0);
7932                 Cvar_SetValueQuick(&r_bloom, 0);
7933                 Cvar_SetValueQuick(&r_motionblur, 0);
7934                 Cvar_SetValueQuick(&r_damageblur, 0);
7935         }
7936
7937         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)))
7938                 screentexturewidth = screentextureheight = 0;
7939         if (!r_hdr.integer && !r_bloom.integer)
7940                 bloomtexturewidth = bloomtextureheight = 0;
7941
7942         // allocate textures as needed
7943         if (r_bloomstate.screentexturewidth != screentexturewidth || r_bloomstate.screentextureheight != screentextureheight)
7944         {
7945                 if (r_bloomstate.texture_screen)
7946                         R_FreeTexture(r_bloomstate.texture_screen);
7947                 r_bloomstate.texture_screen = NULL;
7948                 r_bloomstate.screentexturewidth = screentexturewidth;
7949                 r_bloomstate.screentextureheight = screentextureheight;
7950                 if (r_bloomstate.screentexturewidth && r_bloomstate.screentextureheight)
7951                         r_bloomstate.texture_screen = R_LoadTexture2D(r_main_texturepool, "screen", r_bloomstate.screentexturewidth, r_bloomstate.screentextureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_FORCENEAREST | TEXF_CLAMP, -1, NULL);
7952         }
7953         if (r_bloomstate.bloomtexturewidth != bloomtexturewidth || r_bloomstate.bloomtextureheight != bloomtextureheight)
7954         {
7955                 if (r_bloomstate.texture_bloom)
7956                         R_FreeTexture(r_bloomstate.texture_bloom);
7957                 r_bloomstate.texture_bloom = NULL;
7958                 r_bloomstate.bloomtexturewidth = bloomtexturewidth;
7959                 r_bloomstate.bloomtextureheight = bloomtextureheight;
7960                 if (r_bloomstate.bloomtexturewidth && r_bloomstate.bloomtextureheight)
7961                         r_bloomstate.texture_bloom = R_LoadTexture2D(r_main_texturepool, "bloom", r_bloomstate.bloomtexturewidth, r_bloomstate.bloomtextureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
7962         }
7963
7964         // when doing a reduced render (HDR) we want to use a smaller area
7965         r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, r_refdef.view.height);
7966         r_bloomstate.bloomheight = r_bloomstate.bloomwidth * r_refdef.view.height / r_refdef.view.width;
7967         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_refdef.view.height);
7968         r_bloomstate.bloomwidth = bound(1, r_bloomstate.bloomwidth, r_bloomstate.bloomtexturewidth);
7969         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_bloomstate.bloomtextureheight);
7970
7971         // set up a texcoord array for the full resolution screen image
7972         // (we have to keep this around to copy back during final render)
7973         r_bloomstate.screentexcoord2f[0] = 0;
7974         r_bloomstate.screentexcoord2f[1] = (float)r_refdef.view.height    / (float)r_bloomstate.screentextureheight;
7975         r_bloomstate.screentexcoord2f[2] = (float)r_refdef.view.width     / (float)r_bloomstate.screentexturewidth;
7976         r_bloomstate.screentexcoord2f[3] = (float)r_refdef.view.height    / (float)r_bloomstate.screentextureheight;
7977         r_bloomstate.screentexcoord2f[4] = (float)r_refdef.view.width     / (float)r_bloomstate.screentexturewidth;
7978         r_bloomstate.screentexcoord2f[5] = 0;
7979         r_bloomstate.screentexcoord2f[6] = 0;
7980         r_bloomstate.screentexcoord2f[7] = 0;
7981
7982         // set up a texcoord array for the reduced resolution bloom image
7983         // (which will be additive blended over the screen image)
7984         r_bloomstate.bloomtexcoord2f[0] = 0;
7985         r_bloomstate.bloomtexcoord2f[1] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
7986         r_bloomstate.bloomtexcoord2f[2] = (float)r_bloomstate.bloomwidth  / (float)r_bloomstate.bloomtexturewidth;
7987         r_bloomstate.bloomtexcoord2f[3] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
7988         r_bloomstate.bloomtexcoord2f[4] = (float)r_bloomstate.bloomwidth  / (float)r_bloomstate.bloomtexturewidth;
7989         r_bloomstate.bloomtexcoord2f[5] = 0;
7990         r_bloomstate.bloomtexcoord2f[6] = 0;
7991         r_bloomstate.bloomtexcoord2f[7] = 0;
7992
7993         if (r_hdr.integer || r_bloom.integer)
7994         {
7995                 r_bloomstate.enabled = true;
7996                 r_bloomstate.hdr = r_hdr.integer != 0;
7997         }
7998
7999         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);
8000 }
8001
8002 void R_Bloom_CopyBloomTexture(float colorscale)
8003 {
8004         r_refdef.stats.bloom++;
8005
8006         // scale down screen texture to the bloom texture size
8007         CHECKGLERROR
8008         R_SetViewport(&r_bloomstate.viewport);
8009         GL_BlendFunc(GL_ONE, GL_ZERO);
8010         GL_Color(colorscale, colorscale, colorscale, 1);
8011         // TODO: optimize with multitexture or GLSL
8012         R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
8013         R_SetupShader_Generic(r_bloomstate.texture_screen, NULL, GL_MODULATE, 1);
8014         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
8015         r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
8016
8017         // we now have a bloom image in the framebuffer
8018         // copy it into the bloom image texture for later processing
8019         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);
8020         r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
8021 }
8022
8023 void R_Bloom_CopyHDRTexture(void)
8024 {
8025         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);
8026         r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
8027 }
8028
8029 void R_Bloom_MakeTexture(void)
8030 {
8031         int x, range, dir;
8032         float xoffset, yoffset, r, brighten;
8033
8034         r_refdef.stats.bloom++;
8035
8036         R_ResetViewRendering2D();
8037         R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
8038         R_Mesh_ColorPointer(NULL, 0, 0);
8039
8040         // we have a bloom image in the framebuffer
8041         CHECKGLERROR
8042         R_SetViewport(&r_bloomstate.viewport);
8043
8044         for (x = 1;x < min(r_bloom_colorexponent.value, 32);)
8045         {
8046                 x *= 2;
8047                 r = bound(0, r_bloom_colorexponent.value / x, 1);
8048                 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
8049                 GL_Color(r, r, r, 1);
8050                 R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
8051                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
8052                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
8053                 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
8054
8055                 // copy the vertically blurred bloom view to a texture
8056                 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);
8057                 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
8058         }
8059
8060         range = r_bloom_blur.integer * r_bloomstate.bloomwidth / 320;
8061         brighten = r_bloom_brighten.value;
8062         if (r_hdr.integer)
8063                 brighten *= r_hdr_range.value;
8064         brighten = sqrt(brighten);
8065         if(range >= 1)
8066                 brighten *= (3 * range) / (2 * range - 1); // compensate for the "dot particle"
8067         R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
8068         R_Mesh_TexCoordPointer(0, 2, r_bloomstate.offsettexcoord2f, 0, 0);
8069
8070         for (dir = 0;dir < 2;dir++)
8071         {
8072                 // blend on at multiple vertical offsets to achieve a vertical blur
8073                 // TODO: do offset blends using GLSL
8074                 // TODO instead of changing the texcoords, change the target positions to prevent artifacts at edges
8075                 GL_BlendFunc(GL_ONE, GL_ZERO);
8076                 for (x = -range;x <= range;x++)
8077                 {
8078                         if (!dir){xoffset = 0;yoffset = x;}
8079                         else {xoffset = x;yoffset = 0;}
8080                         xoffset /= (float)r_bloomstate.bloomtexturewidth;
8081                         yoffset /= (float)r_bloomstate.bloomtextureheight;
8082                         // compute a texcoord array with the specified x and y offset
8083                         r_bloomstate.offsettexcoord2f[0] = xoffset+0;
8084                         r_bloomstate.offsettexcoord2f[1] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
8085                         r_bloomstate.offsettexcoord2f[2] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
8086                         r_bloomstate.offsettexcoord2f[3] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
8087                         r_bloomstate.offsettexcoord2f[4] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
8088                         r_bloomstate.offsettexcoord2f[5] = yoffset+0;
8089                         r_bloomstate.offsettexcoord2f[6] = xoffset+0;
8090                         r_bloomstate.offsettexcoord2f[7] = yoffset+0;
8091                         // this r value looks like a 'dot' particle, fading sharply to
8092                         // black at the edges
8093                         // (probably not realistic but looks good enough)
8094                         //r = ((range*range+1)/((float)(x*x+1)))/(range*2+1);
8095                         //r = brighten/(range*2+1);
8096                         r = brighten / (range * 2 + 1);
8097                         if(range >= 1)
8098                                 r *= (1 - x*x/(float)(range*range));
8099                         GL_Color(r, r, r, 1);
8100                         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
8101                         r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
8102                         GL_BlendFunc(GL_ONE, GL_ONE);
8103                 }
8104
8105                 // copy the vertically blurred bloom view to a texture
8106                 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);
8107                 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
8108         }
8109
8110         // apply subtract last
8111         // (just like it would be in a GLSL shader)
8112         if (r_bloom_colorsubtract.value > 0 && vid.support.ext_blend_subtract)
8113         {
8114                 GL_BlendFunc(GL_ONE, GL_ZERO);
8115                 R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
8116                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
8117                 GL_Color(1, 1, 1, 1);
8118                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
8119                 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
8120
8121                 GL_BlendFunc(GL_ONE, GL_ONE);
8122                 qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
8123                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8124                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
8125                 GL_Color(r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 1);
8126                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
8127                 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
8128                 qglBlendEquationEXT(GL_FUNC_ADD_EXT);
8129
8130                 // copy the darkened bloom view to a texture
8131                 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);
8132                 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
8133         }
8134 }
8135
8136 void R_HDR_RenderBloomTexture(void)
8137 {
8138         int oldwidth, oldheight;
8139         float oldcolorscale;
8140
8141         oldcolorscale = r_refdef.view.colorscale;
8142         oldwidth = r_refdef.view.width;
8143         oldheight = r_refdef.view.height;
8144         r_refdef.view.width = r_bloomstate.bloomwidth;
8145         r_refdef.view.height = r_bloomstate.bloomheight;
8146
8147         // TODO: support GL_EXT_framebuffer_object rather than reusing the framebuffer?  it might improve SLI performance.
8148         // TODO: add exposure compensation features
8149         // TODO: add fp16 framebuffer support (using GL_EXT_framebuffer_object)
8150
8151         r_refdef.view.showdebug = false;
8152         r_refdef.view.colorscale *= r_bloom_colorscale.value / bound(1, r_hdr_range.value, 16);
8153
8154         R_ResetViewRendering3D();
8155
8156         R_ClearScreen(r_refdef.fogenabled);
8157         if (r_timereport_active)
8158                 R_TimeReport("HDRclear");
8159
8160         R_View_Update();
8161         if (r_timereport_active)
8162                 R_TimeReport("visibility");
8163
8164         // only do secondary renders with HDR if r_hdr is 2 or higher
8165         r_waterstate.numwaterplanes = 0;
8166         if (r_waterstate.enabled && r_hdr.integer >= 2)
8167                 R_RenderWaterPlanes();
8168
8169         r_refdef.view.showdebug = true;
8170         R_RenderScene();
8171         r_waterstate.numwaterplanes = 0;
8172
8173         R_ResetViewRendering2D();
8174
8175         R_Bloom_CopyHDRTexture();
8176         R_Bloom_MakeTexture();
8177
8178         // restore the view settings
8179         r_refdef.view.width = oldwidth;
8180         r_refdef.view.height = oldheight;
8181         r_refdef.view.colorscale = oldcolorscale;
8182
8183         R_ResetViewRendering3D();
8184
8185         R_ClearScreen(r_refdef.fogenabled);
8186         if (r_timereport_active)
8187                 R_TimeReport("viewclear");
8188 }
8189
8190 static void R_BlendView(void)
8191 {
8192         unsigned int permutation;
8193         float uservecs[4][4];
8194
8195         switch (vid.renderpath)
8196         {
8197         case RENDERPATH_GL20:
8198         case RENDERPATH_CGGL:
8199                 permutation =
8200                           (r_bloomstate.texture_bloom ? SHADERPERMUTATION_BLOOM : 0)
8201                         | (r_refdef.viewblend[3] > 0 ? SHADERPERMUTATION_VIEWTINT : 0)
8202                         | ((v_glslgamma.value && !vid_gammatables_trivial) ? SHADERPERMUTATION_GAMMARAMPS : 0)
8203                         | (r_glsl_postprocess.integer ? SHADERPERMUTATION_POSTPROCESSING : 0)
8204                         | ((!R_Stereo_ColorMasking() && r_glsl_saturation.value != 1) ? SHADERPERMUTATION_SATURATION : 0);
8205
8206                 if (r_bloomstate.texture_screen)
8207                 {
8208                         // make sure the buffer is available
8209                         if (r_bloom_blur.value < 1) { Cvar_SetValueQuick(&r_bloom_blur, 1); }
8210
8211                         R_ResetViewRendering2D();
8212                         R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
8213                         R_Mesh_ColorPointer(NULL, 0, 0);
8214
8215                         if(!R_Stereo_Active() && (r_motionblur.value > 0 || r_damageblur.value > 0))
8216                         {
8217                                 // declare variables
8218                                 float speed;
8219                                 static float avgspeed;
8220
8221                                 speed = VectorLength(cl.movement_velocity);
8222
8223                                 cl.motionbluralpha = bound(0, (cl.time - cl.oldtime) / max(0.001, r_motionblur_vcoeff.value), 1);
8224                                 avgspeed = avgspeed * (1 - cl.motionbluralpha) + speed * cl.motionbluralpha;
8225
8226                                 speed = (avgspeed - r_motionblur_vmin.value) / max(1, r_motionblur_vmax.value - r_motionblur_vmin.value);
8227                                 speed = bound(0, speed, 1);
8228                                 speed = speed * (1 - r_motionblur_bmin.value) + r_motionblur_bmin.value;
8229
8230                                 // calculate values into a standard alpha
8231                                 cl.motionbluralpha = 1 - exp(-
8232                                                 (
8233                                                  (r_motionblur.value * speed / 80)
8234                                                  +
8235                                                  (r_damageblur.value * (cl.cshifts[CSHIFT_DAMAGE].percent / 1600))
8236                                                 )
8237                                                 /
8238                                                 max(0.0001, cl.time - cl.oldtime) // fps independent
8239                                            );
8240
8241                                 cl.motionbluralpha *= lhrandom(1 - r_motionblur_randomize.value, 1 + r_motionblur_randomize.value);
8242                                 cl.motionbluralpha = bound(0, cl.motionbluralpha, r_motionblur_maxblur.value);
8243                                 // apply the blur
8244                                 if (cl.motionbluralpha > 0 && !r_refdef.envmap)
8245                                 {
8246                                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
8247                                         GL_Color(1, 1, 1, cl.motionbluralpha);
8248                                         R_SetupShader_Generic(r_bloomstate.texture_screen, NULL, GL_MODULATE, 1);
8249                                         R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
8250                                         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
8251                                         r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
8252                                 }
8253                         }
8254
8255                         // copy view into the screen texture
8256                         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);
8257                         r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
8258                 }
8259                 else if (!r_bloomstate.texture_bloom)
8260                 {
8261                         // we may still have to do view tint...
8262                         if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
8263                         {
8264                                 // apply a color tint to the whole view
8265                                 R_ResetViewRendering2D();
8266                                 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
8267                                 R_Mesh_ColorPointer(NULL, 0, 0);
8268                                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8269                                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
8270                                 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
8271                                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
8272                         }
8273                         break; // no screen processing, no bloom, skip it
8274                 }
8275
8276                 if (r_bloomstate.texture_bloom && !r_bloomstate.hdr)
8277                 {
8278                         // render simple bloom effect
8279                         // copy the screen and shrink it and darken it for the bloom process
8280                         R_Bloom_CopyBloomTexture(r_bloom_colorscale.value);
8281                         // make the bloom texture
8282                         R_Bloom_MakeTexture();
8283                 }
8284
8285 #if _MSC_VER >= 1400
8286 #define sscanf sscanf_s
8287 #endif
8288                 memset(uservecs, 0, sizeof(uservecs));
8289                 sscanf(r_glsl_postprocess_uservec1.string, "%f %f %f %f", &uservecs[0][0], &uservecs[0][1], &uservecs[0][2], &uservecs[0][3]);
8290                 sscanf(r_glsl_postprocess_uservec2.string, "%f %f %f %f", &uservecs[1][0], &uservecs[1][1], &uservecs[1][2], &uservecs[1][3]);
8291                 sscanf(r_glsl_postprocess_uservec3.string, "%f %f %f %f", &uservecs[2][0], &uservecs[2][1], &uservecs[2][2], &uservecs[2][3]);
8292                 sscanf(r_glsl_postprocess_uservec4.string, "%f %f %f %f", &uservecs[3][0], &uservecs[3][1], &uservecs[3][2], &uservecs[3][3]);
8293
8294                 R_ResetViewRendering2D();
8295                 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
8296                 R_Mesh_ColorPointer(NULL, 0, 0);
8297                 GL_Color(1, 1, 1, 1);
8298                 GL_BlendFunc(GL_ONE, GL_ZERO);
8299                 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
8300                 R_Mesh_TexCoordPointer(1, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
8301
8302                 switch(vid.renderpath)
8303                 {
8304                 case RENDERPATH_GL20:
8305                         R_SetupShader_SetPermutationGLSL(SHADERMODE_POSTPROCESS, permutation);
8306                         if (r_glsl_permutation->loc_Texture_First      >= 0) R_Mesh_TexBind(GL20TU_FIRST     , r_bloomstate.texture_screen);
8307                         if (r_glsl_permutation->loc_Texture_Second     >= 0) R_Mesh_TexBind(GL20TU_SECOND    , r_bloomstate.texture_bloom );
8308                         if (r_glsl_permutation->loc_Texture_GammaRamps >= 0) R_Mesh_TexBind(GL20TU_GAMMARAMPS, r_texture_gammaramps       );
8309                         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]);
8310                         if (r_glsl_permutation->loc_PixelSize          >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelSize         , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);
8311                         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]);
8312                         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]);
8313                         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]);
8314                         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]);
8315                         if (r_glsl_permutation->loc_Saturation         >= 0) qglUniform1fARB(r_glsl_permutation->loc_Saturation        , r_glsl_saturation.value);
8316                         if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
8317                         break;
8318                 case RENDERPATH_CGGL:
8319 #ifdef SUPPORTCG
8320                         R_SetupShader_SetPermutationCG(SHADERMODE_POSTPROCESS, permutation);
8321                         if (r_cg_permutation->fp_Texture_First     ) CG_BindTexture(r_cg_permutation->fp_Texture_First     , r_bloomstate.texture_screen);CHECKCGERROR
8322                         if (r_cg_permutation->fp_Texture_Second    ) CG_BindTexture(r_cg_permutation->fp_Texture_Second    , r_bloomstate.texture_bloom );CHECKCGERROR
8323                         if (r_cg_permutation->fp_Texture_GammaRamps) CG_BindTexture(r_cg_permutation->fp_Texture_GammaRamps, r_texture_gammaramps       );CHECKCGERROR
8324                         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
8325                         if (r_cg_permutation->fp_PixelSize         ) cgGLSetParameter2f(     r_cg_permutation->fp_PixelSize         , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);CHECKCGERROR
8326                         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
8327                         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
8328                         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
8329                         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
8330                         if (r_cg_permutation->fp_Saturation        ) cgGLSetParameter1f(     r_cg_permutation->fp_Saturation        , r_glsl_saturation.value);CHECKCGERROR
8331                         if (r_cg_permutation->fp_PixelToScreenTexCoord) cgGLSetParameter2f(r_cg_permutation->fp_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);CHECKCGERROR
8332 #endif
8333                         break;
8334                 default:
8335                         break;
8336                 }
8337                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
8338                 r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
8339                 break;
8340         case RENDERPATH_GL13:
8341         case RENDERPATH_GL11:
8342                 if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
8343                 {
8344                         // apply a color tint to the whole view
8345                         R_ResetViewRendering2D();
8346                         R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
8347                         R_Mesh_ColorPointer(NULL, 0, 0);
8348                         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8349                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
8350                         GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
8351                         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
8352                 }
8353                 break;
8354         }
8355 }
8356
8357 matrix4x4_t r_waterscrollmatrix;
8358
8359 void R_UpdateFogColor(void) // needs to be called before HDR subrender too, as that changes colorscale!
8360 {
8361         if (r_refdef.fog_density)
8362         {
8363                 r_refdef.fogcolor[0] = r_refdef.fog_red;
8364                 r_refdef.fogcolor[1] = r_refdef.fog_green;
8365                 r_refdef.fogcolor[2] = r_refdef.fog_blue;
8366
8367                 Vector4Set(r_refdef.fogplane, 0, 0, 1, -r_refdef.fog_height);
8368                 r_refdef.fogplaneviewdist = DotProduct(r_refdef.fogplane, r_refdef.view.origin) + r_refdef.fogplane[3];
8369                 r_refdef.fogplaneviewabove = r_refdef.fogplaneviewdist >= 0;
8370                 r_refdef.fogheightfade = -0.5f/max(0.125f, r_refdef.fog_fadedepth);
8371
8372                 {
8373                         vec3_t fogvec;
8374                         VectorCopy(r_refdef.fogcolor, fogvec);
8375                         //   color.rgb *= ContrastBoost * SceneBrightness;
8376                         VectorScale(fogvec, r_refdef.view.colorscale, fogvec);
8377                         r_refdef.fogcolor[0] = bound(0.0f, fogvec[0], 1.0f);
8378                         r_refdef.fogcolor[1] = bound(0.0f, fogvec[1], 1.0f);
8379                         r_refdef.fogcolor[2] = bound(0.0f, fogvec[2], 1.0f);
8380                 }
8381         }
8382 }
8383
8384 void R_UpdateVariables(void)
8385 {
8386         R_Textures_Frame();
8387
8388         r_refdef.scene.ambient = r_ambient.value * (1.0f / 64.0f);
8389
8390         r_refdef.farclip = r_farclip_base.value;
8391         if (r_refdef.scene.worldmodel)
8392                 r_refdef.farclip += r_refdef.scene.worldmodel->radius * r_farclip_world.value * 2;
8393         r_refdef.nearclip = bound (0.001f, r_nearclip.value, r_refdef.farclip - 1.0f);
8394
8395         if (r_shadow_frontsidecasting.integer < 0 || r_shadow_frontsidecasting.integer > 1)
8396                 Cvar_SetValueQuick(&r_shadow_frontsidecasting, 1);
8397         r_refdef.polygonfactor = 0;
8398         r_refdef.polygonoffset = 0;
8399         r_refdef.shadowpolygonfactor = r_refdef.polygonfactor + r_shadow_polygonfactor.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
8400         r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_polygonoffset.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
8401
8402         r_refdef.scene.rtworld = r_shadow_realtime_world.integer != 0;
8403         r_refdef.scene.rtworldshadows = r_shadow_realtime_world_shadows.integer && vid.stencil;
8404         r_refdef.scene.rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer && r_dynamic.integer;
8405         r_refdef.scene.rtdlightshadows = r_refdef.scene.rtdlight && r_shadow_realtime_dlight_shadows.integer && vid.stencil;
8406         r_refdef.lightmapintensity = r_refdef.scene.rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
8407         if (r_showsurfaces.integer)
8408         {
8409                 r_refdef.scene.rtworld = false;
8410                 r_refdef.scene.rtworldshadows = false;
8411                 r_refdef.scene.rtdlight = false;
8412                 r_refdef.scene.rtdlightshadows = false;
8413                 r_refdef.lightmapintensity = 0;
8414         }
8415
8416         if (gamemode == GAME_NEHAHRA)
8417         {
8418                 if (gl_fogenable.integer)
8419                 {
8420                         r_refdef.oldgl_fogenable = true;
8421                         r_refdef.fog_density = gl_fogdensity.value;
8422                         r_refdef.fog_red = gl_fogred.value;
8423                         r_refdef.fog_green = gl_foggreen.value;
8424                         r_refdef.fog_blue = gl_fogblue.value;
8425                         r_refdef.fog_alpha = 1;
8426                         r_refdef.fog_start = 0;
8427                         r_refdef.fog_end = gl_skyclip.value;
8428                         r_refdef.fog_height = 1<<30;
8429                         r_refdef.fog_fadedepth = 128;
8430                 }
8431                 else if (r_refdef.oldgl_fogenable)
8432                 {
8433                         r_refdef.oldgl_fogenable = false;
8434                         r_refdef.fog_density = 0;
8435                         r_refdef.fog_red = 0;
8436                         r_refdef.fog_green = 0;
8437                         r_refdef.fog_blue = 0;
8438                         r_refdef.fog_alpha = 0;
8439                         r_refdef.fog_start = 0;
8440                         r_refdef.fog_end = 0;
8441                         r_refdef.fog_height = 1<<30;
8442                         r_refdef.fog_fadedepth = 128;
8443                 }
8444         }
8445
8446         r_refdef.fog_alpha = bound(0, r_refdef.fog_alpha, 1);
8447         r_refdef.fog_start = max(0, r_refdef.fog_start);
8448         r_refdef.fog_end = max(r_refdef.fog_start + 0.01, r_refdef.fog_end);
8449
8450         // R_UpdateFogColor(); // why? R_RenderScene does it anyway
8451
8452         if (r_refdef.fog_density && r_drawfog.integer)
8453         {
8454                 r_refdef.fogenabled = true;
8455                 // this is the point where the fog reaches 0.9986 alpha, which we
8456                 // consider a good enough cutoff point for the texture
8457                 // (0.9986 * 256 == 255.6)
8458                 if (r_fog_exp2.integer)
8459                         r_refdef.fogrange = 32 / (r_refdef.fog_density * r_refdef.fog_density) + r_refdef.fog_start;
8460                 else
8461                         r_refdef.fogrange = 2048 / r_refdef.fog_density + r_refdef.fog_start;
8462                 r_refdef.fogrange = bound(r_refdef.fog_start, r_refdef.fogrange, r_refdef.fog_end);
8463                 r_refdef.fograngerecip = 1.0f / r_refdef.fogrange;
8464                 r_refdef.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * r_refdef.fograngerecip;
8465                 if (strcmp(r_refdef.fogheighttexturename, r_refdef.fog_height_texturename))
8466                         R_BuildFogHeightTexture();
8467                 // fog color was already set
8468                 // update the fog texture
8469                 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)
8470                         R_BuildFogTexture();
8471                 r_refdef.fog_height_texcoordscale = 1.0f / max(0.125f, r_refdef.fog_fadedepth);
8472                 r_refdef.fog_height_tablescale = r_refdef.fog_height_tablesize * r_refdef.fog_height_texcoordscale;
8473         }
8474         else
8475                 r_refdef.fogenabled = false;
8476
8477         switch(vid.renderpath)
8478         {
8479         case RENDERPATH_GL20:
8480         case RENDERPATH_CGGL:
8481                 if(v_glslgamma.integer && !vid_gammatables_trivial)
8482                 {
8483                         if(!r_texture_gammaramps || vid_gammatables_serial != r_texture_gammaramps_serial)
8484                         {
8485                                 // build GLSL gamma texture
8486 #define RAMPWIDTH 256
8487                                 unsigned short ramp[RAMPWIDTH * 3];
8488                                 unsigned char rampbgr[RAMPWIDTH][4];
8489                                 int i;
8490
8491                                 r_texture_gammaramps_serial = vid_gammatables_serial;
8492
8493                                 VID_BuildGammaTables(&ramp[0], RAMPWIDTH);
8494                                 for(i = 0; i < RAMPWIDTH; ++i)
8495                                 {
8496                                         rampbgr[i][0] = (unsigned char) (ramp[i + 2 * RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
8497                                         rampbgr[i][1] = (unsigned char) (ramp[i + RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
8498                                         rampbgr[i][2] = (unsigned char) (ramp[i] * 255.0 / 65535.0 + 0.5);
8499                                         rampbgr[i][3] = 0;
8500                                 }
8501                                 if (r_texture_gammaramps)
8502                                 {
8503                                         R_UpdateTexture(r_texture_gammaramps, &rampbgr[0][0], 0, 0, RAMPWIDTH, 1);
8504                                 }
8505                                 else
8506                                 {
8507                                         r_texture_gammaramps = R_LoadTexture2D(r_main_texturepool, "gammaramps", RAMPWIDTH, 1, &rampbgr[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL);
8508                                 }
8509                         }
8510                 }
8511                 else
8512                 {
8513                         // remove GLSL gamma texture
8514                 }
8515                 break;
8516         case RENDERPATH_GL13:
8517         case RENDERPATH_GL11:
8518                 break;
8519         }
8520 }
8521
8522 static r_refdef_scene_type_t r_currentscenetype = RST_CLIENT;
8523 static r_refdef_scene_t r_scenes_store[ RST_COUNT ];
8524 /*
8525 ================
8526 R_SelectScene
8527 ================
8528 */
8529 void R_SelectScene( r_refdef_scene_type_t scenetype ) {
8530         if( scenetype != r_currentscenetype ) {
8531                 // store the old scenetype
8532                 r_scenes_store[ r_currentscenetype ] = r_refdef.scene;
8533                 r_currentscenetype = scenetype;
8534                 // move in the new scene
8535                 r_refdef.scene = r_scenes_store[ r_currentscenetype ];
8536         }
8537 }
8538
8539 /*
8540 ================
8541 R_GetScenePointer
8542 ================
8543 */
8544 r_refdef_scene_t * R_GetScenePointer( r_refdef_scene_type_t scenetype )
8545 {
8546         // of course, we could also add a qboolean that provides a lock state and a ReleaseScenePointer function..
8547         if( scenetype == r_currentscenetype ) {
8548                 return &r_refdef.scene;
8549         } else {
8550                 return &r_scenes_store[ scenetype ];
8551         }
8552 }
8553
8554 /*
8555 ================
8556 R_RenderView
8557 ================
8558 */
8559 void R_RenderView(void)
8560 {
8561         if (r_timereport_active)
8562                 R_TimeReport("start");
8563         r_textureframe++; // used only by R_GetCurrentTexture
8564         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
8565
8566         if (!r_drawentities.integer)
8567                 r_refdef.scene.numentities = 0;
8568
8569         R_AnimCache_ClearCache();
8570         R_FrameData_NewFrame();
8571
8572         if (r_refdef.view.isoverlay)
8573         {
8574                 // TODO: FIXME: move this into its own backend function maybe? [2/5/2008 Andreas]
8575                 GL_Clear( GL_DEPTH_BUFFER_BIT );
8576                 R_TimeReport("depthclear");
8577
8578                 r_refdef.view.showdebug = false;
8579
8580                 r_waterstate.enabled = false;
8581                 r_waterstate.numwaterplanes = 0;
8582
8583                 R_RenderScene();
8584
8585                 CHECKGLERROR
8586                 return;
8587         }
8588
8589         if (!r_refdef.scene.entities || r_refdef.view.width * r_refdef.view.height == 0 || !r_renderview.integer || cl_videoplaying/* || !r_refdef.scene.worldmodel*/)
8590                 return; //Host_Error ("R_RenderView: NULL worldmodel");
8591
8592         r_refdef.view.colorscale = r_hdr_scenebrightness.value;
8593
8594         R_RenderView_UpdateViewVectors();
8595
8596         R_Shadow_UpdateWorldLightSelection();
8597
8598         R_Bloom_StartFrame();
8599         R_Water_StartFrame();
8600
8601         CHECKGLERROR
8602         if (r_timereport_active)
8603                 R_TimeReport("viewsetup");
8604
8605         R_ResetViewRendering3D();
8606
8607         if (r_refdef.view.clear || r_refdef.fogenabled)
8608         {
8609                 R_ClearScreen(r_refdef.fogenabled);
8610                 if (r_timereport_active)
8611                         R_TimeReport("viewclear");
8612         }
8613         r_refdef.view.clear = true;
8614
8615         // this produces a bloom texture to be used in R_BlendView() later
8616         if (r_hdr.integer && r_bloomstate.bloomwidth)
8617         {
8618                 R_HDR_RenderBloomTexture();
8619                 // we have to bump the texture frame again because r_refdef.view.colorscale is cached in the textures
8620                 r_textureframe++; // used only by R_GetCurrentTexture
8621         }
8622
8623         r_refdef.view.showdebug = true;
8624
8625         R_View_Update();
8626         if (r_timereport_active)
8627                 R_TimeReport("visibility");
8628
8629         r_waterstate.numwaterplanes = 0;
8630         if (r_waterstate.enabled)
8631                 R_RenderWaterPlanes();
8632
8633         R_RenderScene();
8634         r_waterstate.numwaterplanes = 0;
8635
8636         R_BlendView();
8637         if (r_timereport_active)
8638                 R_TimeReport("blendview");
8639
8640         GL_Scissor(0, 0, vid.width, vid.height);
8641         GL_ScissorTest(false);
8642         CHECKGLERROR
8643 }
8644
8645 void R_RenderWaterPlanes(void)
8646 {
8647         if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawAddWaterPlanes)
8648         {
8649                 r_refdef.scene.worldmodel->DrawAddWaterPlanes(r_refdef.scene.worldentity);
8650                 if (r_timereport_active)
8651                         R_TimeReport("waterworld");
8652         }
8653
8654         // don't let sound skip if going slow
8655         if (r_refdef.scene.extraupdate)
8656                 S_ExtraUpdate ();
8657
8658         R_DrawModelsAddWaterPlanes();
8659         if (r_timereport_active)
8660                 R_TimeReport("watermodels");
8661
8662         if (r_waterstate.numwaterplanes)
8663         {
8664                 R_Water_ProcessPlanes();
8665                 if (r_timereport_active)
8666                         R_TimeReport("waterscenes");
8667         }
8668 }
8669
8670 extern void R_DrawLightningBeams (void);
8671 extern void VM_CL_AddPolygonsToMeshQueue (void);
8672 extern void R_DrawPortals (void);
8673 extern cvar_t cl_locs_show;
8674 static void R_DrawLocs(void);
8675 static void R_DrawEntityBBoxes(void);
8676 static void R_DrawModelDecals(void);
8677 extern void R_DrawModelShadows(void);
8678 extern void R_DrawModelShadowMaps(void);
8679 extern cvar_t cl_decals_newsystem;
8680 extern qboolean r_shadow_usingdeferredprepass;
8681 void R_RenderScene(void)
8682 {
8683         qboolean shadowmapping = false;
8684
8685         if (r_timereport_active)
8686                 R_TimeReport("beginscene");
8687
8688         r_refdef.stats.renders++;
8689
8690         R_UpdateFogColor();
8691
8692         // don't let sound skip if going slow
8693         if (r_refdef.scene.extraupdate)
8694                 S_ExtraUpdate ();
8695
8696         R_MeshQueue_BeginScene();
8697
8698         R_SkyStartFrame();
8699
8700         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);
8701
8702         if (r_timereport_active)
8703                 R_TimeReport("skystartframe");
8704
8705         if (cl.csqc_vidvars.drawworld)
8706         {
8707                 // don't let sound skip if going slow
8708                 if (r_refdef.scene.extraupdate)
8709                         S_ExtraUpdate ();
8710
8711                 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawSky)
8712                 {
8713                         r_refdef.scene.worldmodel->DrawSky(r_refdef.scene.worldentity);
8714                         if (r_timereport_active)
8715                                 R_TimeReport("worldsky");
8716                 }
8717
8718                 if (R_DrawBrushModelsSky() && r_timereport_active)
8719                         R_TimeReport("bmodelsky");
8720
8721                 if (skyrendermasked && skyrenderlater)
8722                 {
8723                         // we have to force off the water clipping plane while rendering sky
8724                         R_SetupView(false);
8725                         R_Sky();
8726                         R_SetupView(true);
8727                         if (r_timereport_active)
8728                                 R_TimeReport("sky");
8729                 }
8730         }
8731
8732         R_AnimCache_CacheVisibleEntities();
8733         if (r_timereport_active)
8734                 R_TimeReport("animation");
8735
8736         R_Shadow_PrepareLights();
8737         if (r_shadows.integer > 0 && r_refdef.lightmapintensity > 0)
8738                 R_Shadow_PrepareModelShadows();
8739         if (r_timereport_active)
8740                 R_TimeReport("preparelights");
8741
8742         if (R_Shadow_ShadowMappingEnabled())
8743                 shadowmapping = true;
8744
8745         if (r_shadow_usingdeferredprepass)
8746                 R_Shadow_DrawPrepass();
8747
8748         if (r_depthfirst.integer >= 1 && cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawDepth)
8749         {
8750                 r_refdef.scene.worldmodel->DrawDepth(r_refdef.scene.worldentity);
8751                 if (r_timereport_active)
8752                         R_TimeReport("worlddepth");
8753         }
8754         if (r_depthfirst.integer >= 2)
8755         {
8756                 R_DrawModelsDepth();
8757                 if (r_timereport_active)
8758                         R_TimeReport("modeldepth");
8759         }
8760
8761         if (r_shadows.integer >= 2 && shadowmapping && r_refdef.lightmapintensity > 0)
8762         {
8763                 R_DrawModelShadowMaps();
8764                 R_ResetViewRendering3D();
8765                 // don't let sound skip if going slow
8766                 if (r_refdef.scene.extraupdate)
8767                         S_ExtraUpdate ();
8768         }
8769
8770         if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->Draw)
8771         {
8772                 r_refdef.scene.worldmodel->Draw(r_refdef.scene.worldentity);
8773                 if (r_timereport_active)
8774                         R_TimeReport("world");
8775         }
8776
8777         // don't let sound skip if going slow
8778         if (r_refdef.scene.extraupdate)
8779                 S_ExtraUpdate ();
8780
8781         R_DrawModels();
8782         if (r_timereport_active)
8783                 R_TimeReport("models");
8784
8785         // don't let sound skip if going slow
8786         if (r_refdef.scene.extraupdate)
8787                 S_ExtraUpdate ();
8788
8789         if ((r_shadows.integer == 1 || (r_shadows.integer > 0 && !shadowmapping)) && !r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0)
8790         {
8791                 R_DrawModelShadows();
8792                 R_ResetViewRendering3D();
8793                 // don't let sound skip if going slow
8794                 if (r_refdef.scene.extraupdate)
8795                         S_ExtraUpdate ();
8796         }
8797
8798         if (!r_shadow_usingdeferredprepass)
8799         {
8800                 R_Shadow_DrawLights();
8801                 if (r_timereport_active)
8802                         R_TimeReport("rtlights");
8803         }
8804
8805         // don't let sound skip if going slow
8806         if (r_refdef.scene.extraupdate)
8807                 S_ExtraUpdate ();
8808
8809         if ((r_shadows.integer == 1 || (r_shadows.integer > 0 && !shadowmapping)) && r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0)
8810         {
8811                 R_DrawModelShadows();
8812                 R_ResetViewRendering3D();
8813                 // don't let sound skip if going slow
8814                 if (r_refdef.scene.extraupdate)
8815                         S_ExtraUpdate ();
8816         }
8817
8818         if (cl.csqc_vidvars.drawworld)
8819         {
8820                 if (cl_decals_newsystem.integer)
8821                 {
8822                         R_DrawModelDecals();
8823                         if (r_timereport_active)
8824                                 R_TimeReport("modeldecals");
8825                 }
8826                 else
8827                 {
8828                         R_DrawDecals();
8829                         if (r_timereport_active)
8830                                 R_TimeReport("decals");
8831                 }
8832
8833                 R_DrawParticles();
8834                 if (r_timereport_active)
8835                         R_TimeReport("particles");
8836
8837                 R_DrawExplosions();
8838                 if (r_timereport_active)
8839                         R_TimeReport("explosions");
8840
8841                 R_DrawLightningBeams();
8842                 if (r_timereport_active)
8843                         R_TimeReport("lightning");
8844         }
8845
8846         VM_CL_AddPolygonsToMeshQueue();
8847
8848         if (r_refdef.view.showdebug)
8849         {
8850                 if (cl_locs_show.integer)
8851                 {
8852                         R_DrawLocs();
8853                         if (r_timereport_active)
8854                                 R_TimeReport("showlocs");
8855                 }
8856
8857                 if (r_drawportals.integer)
8858                 {
8859                         R_DrawPortals();
8860                         if (r_timereport_active)
8861                                 R_TimeReport("portals");
8862                 }
8863
8864                 if (r_showbboxes.value > 0)
8865                 {
8866                         R_DrawEntityBBoxes();
8867                         if (r_timereport_active)
8868                                 R_TimeReport("bboxes");
8869                 }
8870         }
8871
8872         R_MeshQueue_RenderTransparent();
8873         if (r_timereport_active)
8874                 R_TimeReport("drawtrans");
8875
8876         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))
8877         {
8878                 r_refdef.scene.worldmodel->DrawDebug(r_refdef.scene.worldentity);
8879                 if (r_timereport_active)
8880                         R_TimeReport("worlddebug");
8881                 R_DrawModelsDebug();
8882                 if (r_timereport_active)
8883                         R_TimeReport("modeldebug");
8884         }
8885
8886         if (cl.csqc_vidvars.drawworld)
8887         {
8888                 R_Shadow_DrawCoronas();
8889                 if (r_timereport_active)
8890                         R_TimeReport("coronas");
8891         }
8892
8893         // don't let sound skip if going slow
8894         if (r_refdef.scene.extraupdate)
8895                 S_ExtraUpdate ();
8896
8897         R_ResetViewRendering2D();
8898 }
8899
8900 static const unsigned short bboxelements[36] =
8901 {
8902         5, 1, 3, 5, 3, 7,
8903         6, 2, 0, 6, 0, 4,
8904         7, 3, 2, 7, 2, 6,
8905         4, 0, 1, 4, 1, 5,
8906         4, 5, 7, 4, 7, 6,
8907         1, 0, 2, 1, 2, 3,
8908 };
8909
8910 void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
8911 {
8912         int i;
8913         float *v, *c, f1, f2, vertex3f[8*3], color4f[8*4];
8914
8915         RSurf_ActiveWorldEntity();
8916
8917         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
8918         GL_DepthMask(false);
8919         GL_DepthRange(0, 1);
8920         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
8921         R_Mesh_ResetTextureState();
8922
8923         vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2]; //
8924         vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2];
8925         vertex3f[ 6] = mins[0];vertex3f[ 7] = maxs[1];vertex3f[ 8] = mins[2];
8926         vertex3f[ 9] = maxs[0];vertex3f[10] = maxs[1];vertex3f[11] = mins[2];
8927         vertex3f[12] = mins[0];vertex3f[13] = mins[1];vertex3f[14] = maxs[2];
8928         vertex3f[15] = maxs[0];vertex3f[16] = mins[1];vertex3f[17] = maxs[2];
8929         vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
8930         vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
8931         R_FillColors(color4f, 8, cr, cg, cb, ca);
8932         if (r_refdef.fogenabled)
8933         {
8934                 for (i = 0, v = vertex3f, c = color4f;i < 8;i++, v += 3, c += 4)
8935                 {
8936                         f1 = RSurf_FogVertex(v);
8937                         f2 = 1 - f1;
8938                         c[0] = c[0] * f1 + r_refdef.fogcolor[0] * f2;
8939                         c[1] = c[1] * f1 + r_refdef.fogcolor[1] * f2;
8940                         c[2] = c[2] * f1 + r_refdef.fogcolor[2] * f2;
8941                 }
8942         }
8943         R_Mesh_VertexPointer(vertex3f, 0, 0);
8944         R_Mesh_ColorPointer(color4f, 0, 0);
8945         R_Mesh_ResetTextureState();
8946         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8947         R_Mesh_Draw(0, 8, 0, 12, NULL, bboxelements, 0, 0);
8948 }
8949
8950 static void R_DrawEntityBBoxes_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
8951 {
8952         int i;
8953         float color[4];
8954         prvm_edict_t *edict;
8955         prvm_prog_t *prog_save = prog;
8956
8957         // this function draws bounding boxes of server entities
8958         if (!sv.active)
8959                 return;
8960
8961         GL_CullFace(GL_NONE);
8962         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8963
8964         prog = 0;
8965         SV_VM_Begin();
8966         for (i = 0;i < numsurfaces;i++)
8967         {
8968                 edict = PRVM_EDICT_NUM(surfacelist[i]);
8969                 switch ((int)edict->fields.server->solid)
8970                 {
8971                         case SOLID_NOT:      Vector4Set(color, 1, 1, 1, 0.05);break;
8972                         case SOLID_TRIGGER:  Vector4Set(color, 1, 0, 1, 0.10);break;
8973                         case SOLID_BBOX:     Vector4Set(color, 0, 1, 0, 0.10);break;
8974                         case SOLID_SLIDEBOX: Vector4Set(color, 1, 0, 0, 0.10);break;
8975                         case SOLID_BSP:      Vector4Set(color, 0, 0, 1, 0.05);break;
8976                         default:             Vector4Set(color, 0, 0, 0, 0.50);break;
8977                 }
8978                 color[3] *= r_showbboxes.value;
8979                 color[3] = bound(0, color[3], 1);
8980                 GL_DepthTest(!r_showdisabledepthtest.integer);
8981                 GL_CullFace(r_refdef.view.cullface_front);
8982                 R_DrawBBoxMesh(edict->priv.server->areamins, edict->priv.server->areamaxs, color[0], color[1], color[2], color[3]);
8983         }
8984         SV_VM_End();
8985         prog = prog_save;
8986 }
8987
8988 static void R_DrawEntityBBoxes(void)
8989 {
8990         int i;
8991         prvm_edict_t *edict;
8992         vec3_t center;
8993         prvm_prog_t *prog_save = prog;
8994
8995         // this function draws bounding boxes of server entities
8996         if (!sv.active)
8997                 return;
8998
8999         prog = 0;
9000         SV_VM_Begin();
9001         for (i = 0;i < prog->num_edicts;i++)
9002         {
9003                 edict = PRVM_EDICT_NUM(i);
9004                 if (edict->priv.server->free)
9005                         continue;
9006                 // exclude the following for now, as they don't live in world coordinate space and can't be solid:
9007                 if(PRVM_EDICTFIELDVALUE(edict, prog->fieldoffsets.tag_entity)->edict != 0)
9008                         continue;
9009                 if(PRVM_EDICTFIELDVALUE(edict, prog->fieldoffsets.viewmodelforclient)->edict != 0)
9010                         continue;
9011                 VectorLerp(edict->priv.server->areamins, 0.5f, edict->priv.server->areamaxs, center);
9012                 R_MeshQueue_AddTransparent(center, R_DrawEntityBBoxes_Callback, (entity_render_t *)NULL, i, (rtlight_t *)NULL);
9013         }
9014         SV_VM_End();
9015         prog = prog_save;
9016 }
9017
9018 static const int nomodelelement3i[24] =
9019 {
9020         5, 2, 0,
9021         5, 1, 2,
9022         5, 0, 3,
9023         5, 3, 1,
9024         0, 2, 4,
9025         2, 1, 4,
9026         3, 0, 4,
9027         1, 3, 4
9028 };
9029
9030 static const unsigned short nomodelelement3s[24] =
9031 {
9032         5, 2, 0,
9033         5, 1, 2,
9034         5, 0, 3,
9035         5, 3, 1,
9036         0, 2, 4,
9037         2, 1, 4,
9038         3, 0, 4,
9039         1, 3, 4
9040 };
9041
9042 static const float nomodelvertex3f[6*3] =
9043 {
9044         -16,   0,   0,
9045          16,   0,   0,
9046           0, -16,   0,
9047           0,  16,   0,
9048           0,   0, -16,
9049           0,   0,  16
9050 };
9051
9052 static const float nomodelcolor4f[6*4] =
9053 {
9054         0.0f, 0.0f, 0.5f, 1.0f,
9055         0.0f, 0.0f, 0.5f, 1.0f,
9056         0.0f, 0.5f, 0.0f, 1.0f,
9057         0.0f, 0.5f, 0.0f, 1.0f,
9058         0.5f, 0.0f, 0.0f, 1.0f,
9059         0.5f, 0.0f, 0.0f, 1.0f
9060 };
9061
9062 void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
9063 {
9064         int i;
9065         float f1, f2, *c;
9066         float color4f[6*4];
9067
9068         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);
9069
9070         // this is only called once per entity so numsurfaces is always 1, and
9071         // surfacelist is always {0}, so this code does not handle batches
9072
9073         if (rsurface.ent_flags & RENDER_ADDITIVE)
9074         {
9075                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
9076                 GL_DepthMask(false);
9077         }
9078         else if (rsurface.colormod[3] < 1)
9079         {
9080                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
9081                 GL_DepthMask(false);
9082         }
9083         else
9084         {
9085                 GL_BlendFunc(GL_ONE, GL_ZERO);
9086                 GL_DepthMask(true);
9087         }
9088         GL_DepthRange(0, (rsurface.ent_flags & RENDER_VIEWMODEL) ? 0.0625 : 1);
9089         GL_PolygonOffset(rsurface.basepolygonfactor, rsurface.basepolygonoffset);
9090         GL_DepthTest(!(rsurface.ent_flags & RENDER_NODEPTHTEST));
9091         GL_CullFace((rsurface.ent_flags & RENDER_DOUBLESIDED) ? GL_NONE : r_refdef.view.cullface_back);
9092         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9093         R_Mesh_VertexPointer(rsurface.vertex3f, rsurface.vertex3f_bufferobject, rsurface.vertex3f_bufferoffset);
9094         memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
9095         R_Mesh_ColorPointer(color4f, 0, 0);
9096         for (i = 0, c = color4f;i < 6;i++, c += 4)
9097         {
9098                 c[0] *= rsurface.colormod[0];
9099                 c[1] *= rsurface.colormod[1];
9100                 c[2] *= rsurface.colormod[2];
9101                 c[3] *= rsurface.colormod[3];
9102         }
9103         if (r_refdef.fogenabled)
9104         {
9105                 for (i = 0, c = color4f;i < 6;i++, c += 4)
9106                 {
9107                         f1 = RSurf_FogVertex(rsurface.vertex3f + 3*i);
9108                         f2 = 1 - f1;
9109                         c[0] = (c[0] * f1 + r_refdef.fogcolor[0] * f2);
9110                         c[1] = (c[1] * f1 + r_refdef.fogcolor[1] * f2);
9111                         c[2] = (c[2] * f1 + r_refdef.fogcolor[2] * f2);
9112                 }
9113         }
9114         R_Mesh_ResetTextureState();
9115         R_Mesh_Draw(0, 6, 0, 8, nomodelelement3i, nomodelelement3s, 0, 0);
9116 }
9117
9118 void R_DrawNoModel(entity_render_t *ent)
9119 {
9120         vec3_t org;
9121         Matrix4x4_OriginFromMatrix(&ent->matrix, org);
9122         if ((ent->flags & RENDER_ADDITIVE) || (ent->alpha < 1))
9123                 R_MeshQueue_AddTransparent(ent->flags & RENDER_NODEPTHTEST ? r_refdef.view.origin : org, R_DrawNoModel_TransparentCallback, ent, 0, rsurface.rtlight);
9124         else
9125                 R_DrawNoModel_TransparentCallback(ent, rsurface.rtlight, 0, NULL);
9126 }
9127
9128 void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
9129 {
9130         vec3_t right1, right2, diff, normal;
9131
9132         VectorSubtract (org2, org1, normal);
9133
9134         // calculate 'right' vector for start
9135         VectorSubtract (r_refdef.view.origin, org1, diff);
9136         CrossProduct (normal, diff, right1);
9137         VectorNormalize (right1);
9138
9139         // calculate 'right' vector for end
9140         VectorSubtract (r_refdef.view.origin, org2, diff);
9141         CrossProduct (normal, diff, right2);
9142         VectorNormalize (right2);
9143
9144         vert[ 0] = org1[0] + width * right1[0];
9145         vert[ 1] = org1[1] + width * right1[1];
9146         vert[ 2] = org1[2] + width * right1[2];
9147         vert[ 3] = org1[0] - width * right1[0];
9148         vert[ 4] = org1[1] - width * right1[1];
9149         vert[ 5] = org1[2] - width * right1[2];
9150         vert[ 6] = org2[0] - width * right2[0];
9151         vert[ 7] = org2[1] - width * right2[1];
9152         vert[ 8] = org2[2] - width * right2[2];
9153         vert[ 9] = org2[0] + width * right2[0];
9154         vert[10] = org2[1] + width * right2[1];
9155         vert[11] = org2[2] + width * right2[2];
9156 }
9157
9158 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)
9159 {
9160         vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
9161         vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
9162         vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
9163         vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
9164         vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
9165         vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
9166         vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
9167         vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
9168         vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
9169         vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
9170         vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
9171         vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
9172 }
9173
9174 int R_Mesh_AddVertex(rmesh_t *mesh, float x, float y, float z)
9175 {
9176         int i;
9177         float *vertex3f;
9178         float v[3];
9179         VectorSet(v, x, y, z);
9180         for (i = 0, vertex3f = mesh->vertex3f;i < mesh->numvertices;i++, vertex3f += 3)
9181                 if (VectorDistance2(v, vertex3f) < mesh->epsilon2)
9182                         break;
9183         if (i == mesh->numvertices)
9184         {
9185                 if (mesh->numvertices < mesh->maxvertices)
9186                 {
9187                         VectorCopy(v, vertex3f);
9188                         mesh->numvertices++;
9189                 }
9190                 return mesh->numvertices;
9191         }
9192         else
9193                 return i;
9194 }
9195
9196 void R_Mesh_AddPolygon3f(rmesh_t *mesh, int numvertices, float *vertex3f)
9197 {
9198         int i;
9199         int *e, element[3];
9200         element[0] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
9201         element[1] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
9202         e = mesh->element3i + mesh->numtriangles * 3;
9203         for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
9204         {
9205                 element[2] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);
9206                 if (mesh->numtriangles < mesh->maxtriangles)
9207                 {
9208                         *e++ = element[0];
9209                         *e++ = element[1];
9210                         *e++ = element[2];
9211                         mesh->numtriangles++;
9212                 }
9213                 element[1] = element[2];
9214         }
9215 }
9216
9217 void R_Mesh_AddPolygon3d(rmesh_t *mesh, int numvertices, double *vertex3d)
9218 {
9219         int i;
9220         int *e, element[3];
9221         element[0] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
9222         element[1] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
9223         e = mesh->element3i + mesh->numtriangles * 3;
9224         for (i = 0;i < numvertices - 2;i++, vertex3d += 3)
9225         {
9226                 element[2] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);
9227                 if (mesh->numtriangles < mesh->maxtriangles)
9228                 {
9229                         *e++ = element[0];
9230                         *e++ = element[1];
9231                         *e++ = element[2];
9232                         mesh->numtriangles++;
9233                 }
9234                 element[1] = element[2];
9235         }
9236 }
9237
9238 #define R_MESH_PLANE_DIST_EPSILON (1.0 / 32.0)
9239 void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes)
9240 {
9241         int planenum, planenum2;
9242         int w;
9243         int tempnumpoints;
9244         mplane_t *plane, *plane2;
9245         double maxdist;
9246         double temppoints[2][256*3];
9247         // figure out how large a bounding box we need to properly compute this brush
9248         maxdist = 0;
9249         for (w = 0;w < numplanes;w++)
9250                 maxdist = max(maxdist, fabs(planes[w].dist));
9251         // now make it large enough to enclose the entire brush, and round it off to a reasonable multiple of 1024
9252         maxdist = floor(maxdist * (4.0 / 1024.0) + 1) * 1024.0;
9253         for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
9254         {
9255                 w = 0;
9256                 tempnumpoints = 4;
9257                 PolygonD_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, maxdist);
9258                 for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
9259                 {
9260                         if (planenum2 == planenum)
9261                                 continue;
9262                         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);
9263                         w = !w;
9264                 }
9265                 if (tempnumpoints < 3)
9266                         continue;
9267                 // generate elements forming a triangle fan for this polygon
9268                 R_Mesh_AddPolygon3d(mesh, tempnumpoints, temppoints[w]);
9269         }
9270 }
9271
9272 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)
9273 {
9274         texturelayer_t *layer;
9275         layer = t->currentlayers + t->currentnumlayers++;
9276         layer->type = type;
9277         layer->depthmask = depthmask;
9278         layer->blendfunc1 = blendfunc1;
9279         layer->blendfunc2 = blendfunc2;
9280         layer->texture = texture;
9281         layer->texmatrix = *matrix;
9282         layer->color[0] = r;
9283         layer->color[1] = g;
9284         layer->color[2] = b;
9285         layer->color[3] = a;
9286 }
9287
9288 static qboolean R_TestQ3WaveFunc(q3wavefunc_t func, const float *parms)
9289 {
9290         if(parms[0] == 0 && parms[1] == 0)
9291                 return false;
9292         if(func >> Q3WAVEFUNC_USER_SHIFT) // assumes rsurface to be set!
9293                 if(rsurface.userwavefunc_param[bound(0, (func >> Q3WAVEFUNC_USER_SHIFT) - 1, Q3WAVEFUNC_USER_COUNT)] == 0)
9294                         return false;
9295         return true;
9296 }
9297
9298 static float R_EvaluateQ3WaveFunc(q3wavefunc_t func, const float *parms)
9299 {
9300         double index, f;
9301         index = parms[2] + r_refdef.scene.time * parms[3];
9302         index -= floor(index);
9303         switch (func & ((1 << Q3WAVEFUNC_USER_SHIFT) - 1))
9304         {
9305         default:
9306         case Q3WAVEFUNC_NONE:
9307         case Q3WAVEFUNC_NOISE:
9308         case Q3WAVEFUNC_COUNT:
9309                 f = 0;
9310                 break;
9311         case Q3WAVEFUNC_SIN: f = sin(index * M_PI * 2);break;
9312         case Q3WAVEFUNC_SQUARE: f = index < 0.5 ? 1 : -1;break;
9313         case Q3WAVEFUNC_SAWTOOTH: f = index;break;
9314         case Q3WAVEFUNC_INVERSESAWTOOTH: f = 1 - index;break;
9315         case Q3WAVEFUNC_TRIANGLE:
9316                 index *= 4;
9317                 f = index - floor(index);
9318                 if (index < 1)
9319                         f = f;
9320                 else if (index < 2)
9321                         f = 1 - f;
9322                 else if (index < 3)
9323                         f = -f;
9324                 else
9325                         f = -(1 - f);
9326                 break;
9327         }
9328         f = parms[0] + parms[1] * f;
9329         if(func >> Q3WAVEFUNC_USER_SHIFT) // assumes rsurface to be set!
9330                 f *= rsurface.userwavefunc_param[bound(0, (func >> Q3WAVEFUNC_USER_SHIFT) - 1, Q3WAVEFUNC_USER_COUNT)];
9331         return (float) f;
9332 }
9333
9334 void R_tcMod_ApplyToMatrix(matrix4x4_t *texmatrix, q3shaderinfo_layer_tcmod_t *tcmod, int currentmaterialflags)
9335 {
9336         int w, h, idx;
9337         float f;
9338         float tcmat[12];
9339         matrix4x4_t matrix, temp;
9340         switch(tcmod->tcmod)
9341         {
9342                 case Q3TCMOD_COUNT:
9343                 case Q3TCMOD_NONE:
9344                         if (currentmaterialflags & MATERIALFLAG_WATERSCROLL)
9345                                 matrix = r_waterscrollmatrix;
9346                         else
9347                                 matrix = identitymatrix;
9348                         break;
9349                 case Q3TCMOD_ENTITYTRANSLATE:
9350                         // this is used in Q3 to allow the gamecode to control texcoord
9351                         // scrolling on the entity, which is not supported in darkplaces yet.
9352                         Matrix4x4_CreateTranslate(&matrix, 0, 0, 0);
9353                         break;
9354                 case Q3TCMOD_ROTATE:
9355                         Matrix4x4_CreateTranslate(&matrix, 0.5, 0.5, 0);
9356                         Matrix4x4_ConcatRotate(&matrix, tcmod->parms[0] * r_refdef.scene.time, 0, 0, 1);
9357                         Matrix4x4_ConcatTranslate(&matrix, -0.5, -0.5, 0);
9358                         break;
9359                 case Q3TCMOD_SCALE:
9360                         Matrix4x4_CreateScale3(&matrix, tcmod->parms[0], tcmod->parms[1], 1);
9361                         break;
9362                 case Q3TCMOD_SCROLL:
9363                         Matrix4x4_CreateTranslate(&matrix, tcmod->parms[0] * r_refdef.scene.time, tcmod->parms[1] * r_refdef.scene.time, 0);
9364                         break;
9365                 case Q3TCMOD_PAGE: // poor man's animmap (to store animations into a single file, useful for HTTP downloaded textures)
9366                         w = (int) tcmod->parms[0];
9367                         h = (int) tcmod->parms[1];
9368                         f = r_refdef.scene.time / (tcmod->parms[2] * w * h);
9369                         f = f - floor(f);
9370                         idx = (int) floor(f * w * h);
9371                         Matrix4x4_CreateTranslate(&matrix, (idx % w) / tcmod->parms[0], (idx / w) / tcmod->parms[1], 0);
9372                         break;
9373                 case Q3TCMOD_STRETCH:
9374                         f = 1.0f / R_EvaluateQ3WaveFunc(tcmod->wavefunc, tcmod->waveparms);
9375                         Matrix4x4_CreateFromQuakeEntity(&matrix, 0.5f * (1 - f), 0.5 * (1 - f), 0, 0, 0, 0, f);
9376                         break;
9377                 case Q3TCMOD_TRANSFORM:
9378                         VectorSet(tcmat +  0, tcmod->parms[0], tcmod->parms[1], 0);
9379                         VectorSet(tcmat +  3, tcmod->parms[2], tcmod->parms[3], 0);
9380                         VectorSet(tcmat +  6, 0                   , 0                , 1);
9381                         VectorSet(tcmat +  9, tcmod->parms[4], tcmod->parms[5], 0);
9382                         Matrix4x4_FromArray12FloatGL(&matrix, tcmat);
9383                         break;
9384                 case Q3TCMOD_TURBULENT:
9385                         // this is handled in the RSurf_PrepareVertices function
9386                         matrix = identitymatrix;
9387                         break;
9388         }
9389         temp = *texmatrix;
9390         Matrix4x4_Concat(texmatrix, &matrix, &temp);
9391 }
9392
9393 void R_LoadQWSkin(r_qwskincache_t *cache, const char *skinname)
9394 {
9395         int textureflags = (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_PICMIP | TEXF_COMPRESS;
9396         char name[MAX_QPATH];
9397         skinframe_t *skinframe;
9398         unsigned char pixels[296*194];
9399         strlcpy(cache->name, skinname, sizeof(cache->name));
9400         dpsnprintf(name, sizeof(name), "skins/%s.pcx", cache->name);
9401         if (developer_loading.integer)
9402                 Con_Printf("loading %s\n", name);
9403         skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
9404         if (!skinframe || !skinframe->base)
9405         {
9406                 unsigned char *f;
9407                 fs_offset_t filesize;
9408                 skinframe = NULL;
9409                 f = FS_LoadFile(name, tempmempool, true, &filesize);
9410                 if (f)
9411                 {
9412                         if (LoadPCX_QWSkin(f, (int)filesize, pixels, 296, 194))
9413                                 skinframe = R_SkinFrame_LoadInternalQuake(name, textureflags, true, r_fullbrights.integer, pixels, image_width, image_height);
9414                         Mem_Free(f);
9415                 }
9416         }
9417         cache->skinframe = skinframe;
9418 }
9419
9420 texture_t *R_GetCurrentTexture(texture_t *t)
9421 {
9422         int i;
9423         const entity_render_t *ent = rsurface.entity;
9424         dp_model_t *model = ent->model;
9425         q3shaderinfo_layer_tcmod_t *tcmod;
9426
9427         if (t->update_lastrenderframe == r_textureframe && t->update_lastrenderentity == (void *)ent)
9428                 return t->currentframe;
9429         t->update_lastrenderframe = r_textureframe;
9430         t->update_lastrenderentity = (void *)ent;
9431
9432         if(ent && ent->entitynumber >= MAX_EDICTS && ent->entitynumber < 2 * MAX_EDICTS)
9433                 t->camera_entity = ent->entitynumber;
9434         else
9435                 t->camera_entity = 0;
9436
9437         // switch to an alternate material if this is a q1bsp animated material
9438         {
9439                 texture_t *texture = t;
9440                 int s = rsurface.ent_skinnum;
9441                 if ((unsigned int)s >= (unsigned int)model->numskins)
9442                         s = 0;
9443                 if (model->skinscenes)
9444                 {
9445                         if (model->skinscenes[s].framecount > 1)
9446                                 s = model->skinscenes[s].firstframe + (unsigned int) (r_refdef.scene.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
9447                         else
9448                                 s = model->skinscenes[s].firstframe;
9449                 }
9450                 if (s > 0)
9451                         t = t + s * model->num_surfaces;
9452                 if (t->animated)
9453                 {
9454                         // use an alternate animation if the entity's frame is not 0,
9455                         // and only if the texture has an alternate animation
9456                         if (rsurface.ent_alttextures && t->anim_total[1])
9457                                 t = t->anim_frames[1][(t->anim_total[1] >= 2) ? ((int)(r_refdef.scene.time * 5.0f) % t->anim_total[1]) : 0];
9458                         else
9459                                 t = t->anim_frames[0][(t->anim_total[0] >= 2) ? ((int)(r_refdef.scene.time * 5.0f) % t->anim_total[0]) : 0];
9460                 }
9461                 texture->currentframe = t;
9462         }
9463
9464         // update currentskinframe to be a qw skin or animation frame
9465         if (rsurface.ent_qwskin >= 0)
9466         {
9467                 i = rsurface.ent_qwskin;
9468                 if (!r_qwskincache || r_qwskincache_size != cl.maxclients)
9469                 {
9470                         r_qwskincache_size = cl.maxclients;
9471                         if (r_qwskincache)
9472                                 Mem_Free(r_qwskincache);
9473                         r_qwskincache = Mem_Alloc(r_main_mempool, sizeof(*r_qwskincache) * r_qwskincache_size);
9474                 }
9475                 if (strcmp(r_qwskincache[i].name, cl.scores[i].qw_skin))
9476                         R_LoadQWSkin(&r_qwskincache[i], cl.scores[i].qw_skin);
9477                 t->currentskinframe = r_qwskincache[i].skinframe;
9478                 if (t->currentskinframe == NULL)
9479                         t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes];
9480         }
9481         else if (t->numskinframes >= 2)
9482                 t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes];
9483         if (t->backgroundnumskinframes >= 2)
9484                 t->backgroundcurrentskinframe = t->backgroundskinframes[(int)(t->backgroundskinframerate * (cl.time - rsurface.ent_shadertime)) % t->backgroundnumskinframes];
9485
9486         t->currentmaterialflags = t->basematerialflags;
9487         t->currentalpha = rsurface.colormod[3];
9488         if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_novis.integer))
9489                 t->currentalpha *= r_wateralpha.value;
9490         if(t->basematerialflags & MATERIALFLAG_WATERSHADER && r_waterstate.enabled && !r_refdef.view.isoverlay)
9491                 t->currentalpha *= t->r_water_wateralpha;
9492         if(!r_waterstate.enabled || r_refdef.view.isoverlay)
9493                 t->currentmaterialflags &= ~(MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA);
9494         if (!(rsurface.ent_flags & RENDER_LIGHT))
9495                 t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
9496         else if (rsurface.modeltexcoordlightmap2f == NULL && !(t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
9497         {
9498                 // pick a model lighting mode
9499                 if (VectorLength2(rsurface.modellight_diffuse) >= (1.0f / 256.0f))
9500                         t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL;
9501                 else
9502                         t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT;
9503         }
9504         if (rsurface.ent_flags & RENDER_ADDITIVE)
9505                 t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
9506         else if (t->currentalpha < 1)
9507                 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
9508         if (rsurface.ent_flags & RENDER_DOUBLESIDED)
9509                 t->currentmaterialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_NOCULLFACE;
9510         if (rsurface.ent_flags & (RENDER_NODEPTHTEST | RENDER_VIEWMODEL))
9511                 t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
9512         if (t->backgroundnumskinframes)
9513                 t->currentmaterialflags |= MATERIALFLAG_VERTEXTEXTUREBLEND;
9514         if (t->currentmaterialflags & MATERIALFLAG_BLENDED)
9515         {
9516                 if (t->currentmaterialflags & (MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER | MATERIALFLAG_CAMERA))
9517                         t->currentmaterialflags &= ~MATERIALFLAG_BLENDED;
9518         }
9519         else
9520                 t->currentmaterialflags &= ~(MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER | MATERIALFLAG_CAMERA);
9521         if ((t->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST)) == MATERIALFLAG_BLENDED && r_transparentdepthmasking.integer && !(t->basematerialflags & MATERIALFLAG_BLENDED))
9522                 t->currentmaterialflags |= MATERIALFLAG_TRANSDEPTH;
9523
9524         // there is no tcmod
9525         if (t->currentmaterialflags & MATERIALFLAG_WATERSCROLL)
9526         {
9527                 t->currenttexmatrix = r_waterscrollmatrix;
9528                 t->currentbackgroundtexmatrix = r_waterscrollmatrix;
9529         }
9530         else if (!(t->currentmaterialflags & MATERIALFLAG_CUSTOMSURFACE))
9531         {
9532                 Matrix4x4_CreateIdentity(&t->currenttexmatrix);
9533                 Matrix4x4_CreateIdentity(&t->currentbackgroundtexmatrix);
9534         }
9535
9536         for (i = 0, tcmod = t->tcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
9537                 R_tcMod_ApplyToMatrix(&t->currenttexmatrix, tcmod, t->currentmaterialflags);
9538         for (i = 0, tcmod = t->backgroundtcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
9539                 R_tcMod_ApplyToMatrix(&t->currentbackgroundtexmatrix, tcmod, t->currentmaterialflags);
9540
9541         t->colormapping = VectorLength2(rsurface.colormap_pantscolor) + VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f);
9542         if (t->currentskinframe->qpixels)
9543                 R_SkinFrame_GenerateTexturesFromQPixels(t->currentskinframe, t->colormapping);
9544         t->basetexture = (!t->colormapping && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
9545         if (!t->basetexture)
9546                 t->basetexture = r_texture_notexture;
9547         t->pantstexture = t->colormapping ? t->currentskinframe->pants : NULL;
9548         t->shirttexture = t->colormapping ? t->currentskinframe->shirt : NULL;
9549         t->nmaptexture = t->currentskinframe->nmap;
9550         if (!t->nmaptexture)
9551                 t->nmaptexture = r_texture_blanknormalmap;
9552         t->glosstexture = r_texture_black;
9553         t->glowtexture = t->currentskinframe->glow;
9554         t->fogtexture = t->currentskinframe->fog;
9555         t->reflectmasktexture = t->currentskinframe->reflect;
9556         if (t->backgroundnumskinframes)
9557         {
9558                 t->backgroundbasetexture = (!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base;
9559                 t->backgroundnmaptexture = t->backgroundcurrentskinframe->nmap;
9560                 t->backgroundglosstexture = r_texture_black;
9561                 t->backgroundglowtexture = t->backgroundcurrentskinframe->glow;
9562                 if (!t->backgroundnmaptexture)
9563                         t->backgroundnmaptexture = r_texture_blanknormalmap;
9564         }
9565         else
9566         {
9567                 t->backgroundbasetexture = t->backgroundnumskinframes ? ((!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base) : r_texture_white;
9568                 t->backgroundnmaptexture = r_texture_blanknormalmap;
9569                 t->backgroundglosstexture = r_texture_black;
9570                 t->backgroundglowtexture = NULL;
9571         }
9572         t->specularpower = r_shadow_glossexponent.value;
9573         // TODO: store reference values for these in the texture?
9574         t->specularscale = 0;
9575         if (r_shadow_gloss.integer > 0)
9576         {
9577                 if (t->currentskinframe->gloss || (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss))
9578                 {
9579                         if (r_shadow_glossintensity.value > 0)
9580                         {
9581                                 t->glosstexture = t->currentskinframe->gloss ? t->currentskinframe->gloss : r_texture_white;
9582                                 t->backgroundglosstexture = (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss) ? t->backgroundcurrentskinframe->gloss : r_texture_white;
9583                                 t->specularscale = r_shadow_glossintensity.value;
9584                         }
9585                 }
9586                 else if (r_shadow_gloss.integer >= 2 && r_shadow_gloss2intensity.value > 0)
9587                 {
9588                         t->glosstexture = r_texture_white;
9589                         t->backgroundglosstexture = r_texture_white;
9590                         t->specularscale = r_shadow_gloss2intensity.value;
9591                         t->specularpower = r_shadow_gloss2exponent.value;
9592                 }
9593         }
9594         t->specularscale *= t->specularscalemod;
9595         t->specularpower *= t->specularpowermod;
9596
9597         // lightmaps mode looks bad with dlights using actual texturing, so turn
9598         // off the colormap and glossmap, but leave the normalmap on as it still
9599         // accurately represents the shading involved
9600         if (gl_lightmaps.integer)
9601         {
9602                 t->basetexture = r_texture_grey128;
9603                 t->pantstexture = r_texture_black;
9604                 t->shirttexture = r_texture_black;
9605                 t->nmaptexture = r_texture_blanknormalmap;
9606                 t->glosstexture = r_texture_black;
9607                 t->glowtexture = NULL;
9608                 t->fogtexture = NULL;
9609                 t->reflectmasktexture = NULL;
9610                 t->backgroundbasetexture = NULL;
9611                 t->backgroundnmaptexture = r_texture_blanknormalmap;
9612                 t->backgroundglosstexture = r_texture_black;
9613                 t->backgroundglowtexture = NULL;
9614                 t->specularscale = 0;
9615                 t->currentmaterialflags = MATERIALFLAG_WALL | (t->currentmaterialflags & (MATERIALFLAG_NOCULLFACE | MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SHORTDEPTHRANGE));
9616         }
9617
9618         Vector4Set(t->lightmapcolor, rsurface.colormod[0], rsurface.colormod[1], rsurface.colormod[2], t->currentalpha);
9619         VectorClear(t->dlightcolor);
9620         t->currentnumlayers = 0;
9621         if (t->currentmaterialflags & MATERIALFLAG_WALL)
9622         {
9623                 int blendfunc1, blendfunc2;
9624                 qboolean depthmask;
9625                 if (t->currentmaterialflags & MATERIALFLAG_ADD)
9626                 {
9627                         blendfunc1 = GL_SRC_ALPHA;
9628                         blendfunc2 = GL_ONE;
9629                 }
9630                 else if (t->currentmaterialflags & MATERIALFLAG_ALPHA)
9631                 {
9632                         blendfunc1 = GL_SRC_ALPHA;
9633                         blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
9634                 }
9635                 else if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
9636                 {
9637                         blendfunc1 = t->customblendfunc[0];
9638                         blendfunc2 = t->customblendfunc[1];
9639                 }
9640                 else
9641                 {
9642                         blendfunc1 = GL_ONE;
9643                         blendfunc2 = GL_ZERO;
9644                 }
9645                 // don't colormod evilblend textures
9646                 if(!R_BlendFuncAllowsColormod(blendfunc1, blendfunc2))
9647                         VectorSet(t->lightmapcolor, 1, 1, 1);
9648                 depthmask = !(t->currentmaterialflags & MATERIALFLAG_BLENDED);
9649                 if (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
9650                 {
9651                         // fullbright is not affected by r_refdef.lightmapintensity
9652                         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]);
9653                         if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
9654                                 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]);
9655                         if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
9656                                 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]);
9657                 }
9658                 else
9659                 {
9660                         vec3_t ambientcolor;
9661                         float colorscale;
9662                         // set the color tint used for lights affecting this surface
9663                         VectorSet(t->dlightcolor, t->lightmapcolor[0] * t->lightmapcolor[3], t->lightmapcolor[1] * t->lightmapcolor[3], t->lightmapcolor[2] * t->lightmapcolor[3]);
9664                         colorscale = 2;
9665                         // q3bsp has no lightmap updates, so the lightstylevalue that
9666                         // would normally be baked into the lightmap must be
9667                         // applied to the color
9668                         // FIXME: r_glsl 1 rendering doesn't support overbright lightstyles with this (the default light style is not overbright)
9669                         if (model->type == mod_brushq3)
9670                                 colorscale *= r_refdef.scene.rtlightstylevalue[0];
9671                         colorscale *= r_refdef.lightmapintensity;
9672                         VectorScale(t->lightmapcolor, r_refdef.scene.ambient, ambientcolor);
9673                         VectorScale(t->lightmapcolor, colorscale, t->lightmapcolor);
9674                         // basic lit geometry
9675                         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]);
9676                         // add pants/shirt if needed
9677                         if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
9678                                 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]);
9679                         if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
9680                                 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]);
9681                         // now add ambient passes if needed
9682                         if (VectorLength2(ambientcolor) >= (1.0f/1048576.0f))
9683                         {
9684                                 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]);
9685                                 if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
9686                                         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]);
9687                                 if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
9688                                         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]);
9689                         }
9690                 }
9691                 if (t->glowtexture != NULL && !gl_lightmaps.integer)
9692                         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]);
9693                 if (r_refdef.fogenabled && !(t->currentmaterialflags & MATERIALFLAG_ADD))
9694                 {
9695                         // if this is opaque use alpha blend which will darken the earlier
9696                         // passes cheaply.
9697                         //
9698                         // if this is an alpha blended material, all the earlier passes
9699                         // were darkened by fog already, so we only need to add the fog
9700                         // color ontop through the fog mask texture
9701                         //
9702                         // if this is an additive blended material, all the earlier passes
9703                         // were darkened by fog already, and we should not add fog color
9704                         // (because the background was not darkened, there is no fog color
9705                         // that was lost behind it).
9706                         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]);
9707                 }
9708         }
9709
9710         return t->currentframe;
9711 }
9712
9713 rsurfacestate_t rsurface;
9714
9715 void R_Mesh_ResizeArrays(int newvertices)
9716 {
9717         float *base;
9718         if (rsurface.array_size >= newvertices)
9719                 return;
9720         if (rsurface.array_modelvertex3f)
9721                 Mem_Free(rsurface.array_modelvertex3f);
9722         rsurface.array_size = (newvertices + 1023) & ~1023;
9723         base = (float *)Mem_Alloc(r_main_mempool, rsurface.array_size * sizeof(float[33]));
9724         rsurface.array_modelvertex3f     = base + rsurface.array_size * 0;
9725         rsurface.array_modelsvector3f    = base + rsurface.array_size * 3;
9726         rsurface.array_modeltvector3f    = base + rsurface.array_size * 6;
9727         rsurface.array_modelnormal3f     = base + rsurface.array_size * 9;
9728         rsurface.array_deformedvertex3f  = base + rsurface.array_size * 12;
9729         rsurface.array_deformedsvector3f = base + rsurface.array_size * 15;
9730         rsurface.array_deformedtvector3f = base + rsurface.array_size * 18;
9731         rsurface.array_deformednormal3f  = base + rsurface.array_size * 21;
9732         rsurface.array_texcoord3f        = base + rsurface.array_size * 24;
9733         rsurface.array_color4f           = base + rsurface.array_size * 27;
9734         rsurface.array_generatedtexcoordtexture2f = base + rsurface.array_size * 31;
9735 }
9736
9737 void RSurf_ActiveWorldEntity(void)
9738 {
9739         dp_model_t *model = r_refdef.scene.worldmodel;
9740         //if (rsurface.entity == r_refdef.scene.worldentity)
9741         //      return;
9742         rsurface.entity = r_refdef.scene.worldentity;
9743         rsurface.skeleton = NULL;
9744         memset(rsurface.userwavefunc_param, 0, sizeof(rsurface.userwavefunc_param));
9745         rsurface.ent_skinnum = 0;
9746         rsurface.ent_qwskin = -1;
9747         rsurface.ent_shadertime = 0;
9748         rsurface.ent_flags = r_refdef.scene.worldentity->flags;
9749         if (rsurface.array_size < model->surfmesh.num_vertices)
9750                 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
9751         rsurface.matrix = identitymatrix;
9752         rsurface.inversematrix = identitymatrix;
9753         rsurface.matrixscale = 1;
9754         rsurface.inversematrixscale = 1;
9755         R_EntityMatrix(&identitymatrix);
9756         VectorCopy(r_refdef.view.origin, rsurface.localvieworigin);
9757         Vector4Copy(r_refdef.fogplane, rsurface.fogplane);
9758         rsurface.fograngerecip = r_refdef.fograngerecip;
9759         rsurface.fogheightfade = r_refdef.fogheightfade;
9760         rsurface.fogplaneviewdist = r_refdef.fogplaneviewdist;
9761         rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
9762         VectorSet(rsurface.modellight_ambient, 0, 0, 0);
9763         VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
9764         VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
9765         VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
9766         VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
9767         VectorSet(rsurface.colormod, r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale);
9768         rsurface.colormod[3] = 1;
9769         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);
9770         memset(rsurface.frameblend, 0, sizeof(rsurface.frameblend));
9771         rsurface.frameblend[0].lerp = 1;
9772         rsurface.ent_alttextures = false;
9773         rsurface.basepolygonfactor = r_refdef.polygonfactor;
9774         rsurface.basepolygonoffset = r_refdef.polygonoffset;
9775         rsurface.modelvertex3f  = model->surfmesh.data_vertex3f;
9776         rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
9777         rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
9778         rsurface.modelsvector3f = model->surfmesh.data_svector3f;
9779         rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
9780         rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
9781         rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
9782         rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
9783         rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
9784         rsurface.modelnormal3f  = model->surfmesh.data_normal3f;
9785         rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
9786         rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
9787         rsurface.modellightmapcolor4f  = model->surfmesh.data_lightmapcolor4f;
9788         rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
9789         rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
9790         rsurface.modeltexcoordtexture2f  = model->surfmesh.data_texcoordtexture2f;
9791         rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
9792         rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
9793         rsurface.modeltexcoordlightmap2f  = model->surfmesh.data_texcoordlightmap2f;
9794         rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
9795         rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
9796         rsurface.modelelement3i = model->surfmesh.data_element3i;
9797         rsurface.modelelement3s = model->surfmesh.data_element3s;
9798         rsurface.modelelement3i_bufferobject = model->surfmesh.ebo3i;
9799         rsurface.modelelement3s_bufferobject = model->surfmesh.ebo3s;
9800         rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
9801         rsurface.modelnum_vertices = model->surfmesh.num_vertices;
9802         rsurface.modelnum_triangles = model->surfmesh.num_triangles;
9803         rsurface.modelsurfaces = model->data_surfaces;
9804         rsurface.generatedvertex = false;
9805         rsurface.vertex3f  = rsurface.modelvertex3f;
9806         rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
9807         rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
9808         rsurface.svector3f = rsurface.modelsvector3f;
9809         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
9810         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
9811         rsurface.tvector3f = rsurface.modeltvector3f;
9812         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
9813         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
9814         rsurface.normal3f  = rsurface.modelnormal3f;
9815         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
9816         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
9817         rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
9818 }
9819
9820 void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents, qboolean prepass)
9821 {
9822         dp_model_t *model = ent->model;
9823         //if (rsurface.entity == ent && (!model->surfmesh.isanimated || (!wantnormals && !wanttangents)))
9824         //      return;
9825         rsurface.entity = (entity_render_t *)ent;
9826         rsurface.skeleton = ent->skeleton;
9827         memcpy(rsurface.userwavefunc_param, ent->userwavefunc_param, sizeof(rsurface.userwavefunc_param));
9828         rsurface.ent_skinnum = ent->skinnum;
9829         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;
9830         rsurface.ent_shadertime = ent->shadertime;
9831         rsurface.ent_flags = ent->flags;
9832         if (rsurface.array_size < model->surfmesh.num_vertices)
9833                 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
9834         rsurface.matrix = ent->matrix;
9835         rsurface.inversematrix = ent->inversematrix;
9836         rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
9837         rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
9838         R_EntityMatrix(&rsurface.matrix);
9839         Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
9840         Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
9841         rsurface.fogplaneviewdist *= rsurface.inversematrixscale;
9842         rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
9843         rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
9844         rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
9845         VectorCopy(ent->modellight_ambient, rsurface.modellight_ambient);
9846         VectorCopy(ent->modellight_diffuse, rsurface.modellight_diffuse);
9847         VectorCopy(ent->modellight_lightdir, rsurface.modellight_lightdir);
9848         VectorCopy(ent->colormap_pantscolor, rsurface.colormap_pantscolor);
9849         VectorCopy(ent->colormap_shirtcolor, rsurface.colormap_shirtcolor);
9850         VectorScale(ent->colormod, r_refdef.view.colorscale, rsurface.colormod);
9851         rsurface.colormod[3] = ent->alpha;
9852         VectorScale(ent->glowmod, r_refdef.view.colorscale * r_hdr_glowintensity.value, rsurface.glowmod);
9853         memcpy(rsurface.frameblend, ent->frameblend, sizeof(ent->frameblend));
9854         rsurface.ent_alttextures = ent->framegroupblend[0].frame != 0;
9855         rsurface.basepolygonfactor = r_refdef.polygonfactor;
9856         rsurface.basepolygonoffset = r_refdef.polygonoffset;
9857         if (ent->model->brush.submodel && !prepass)
9858         {
9859                 rsurface.basepolygonfactor += r_polygonoffset_submodel_factor.value;
9860                 rsurface.basepolygonoffset += r_polygonoffset_submodel_offset.value;
9861         }
9862         if (model->surfmesh.isanimated && model->AnimateVertices && (rsurface.frameblend[0].lerp != 1 || rsurface.frameblend[0].subframe != 0))
9863         {
9864                 if (ent->animcache_vertex3f && !r_framedata_failed)
9865                 {
9866                         rsurface.modelvertex3f = ent->animcache_vertex3f;
9867                         rsurface.modelsvector3f = wanttangents ? ent->animcache_svector3f : NULL;
9868                         rsurface.modeltvector3f = wanttangents ? ent->animcache_tvector3f : NULL;
9869                         rsurface.modelnormal3f = wantnormals ? ent->animcache_normal3f : NULL;
9870                 }
9871                 else if (wanttangents)
9872                 {
9873                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
9874                         rsurface.modelsvector3f = rsurface.array_modelsvector3f;
9875                         rsurface.modeltvector3f = rsurface.array_modeltvector3f;
9876                         rsurface.modelnormal3f = rsurface.array_modelnormal3f;
9877                         model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f);
9878                 }
9879                 else if (wantnormals)
9880                 {
9881                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
9882                         rsurface.modelsvector3f = NULL;
9883                         rsurface.modeltvector3f = NULL;
9884                         rsurface.modelnormal3f = rsurface.array_modelnormal3f;
9885                         model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, NULL, NULL);
9886                 }
9887                 else
9888                 {
9889                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
9890                         rsurface.modelsvector3f = NULL;
9891                         rsurface.modeltvector3f = NULL;
9892                         rsurface.modelnormal3f = NULL;
9893                         model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, NULL, NULL, NULL);
9894                 }
9895                 rsurface.modelvertex3f_bufferobject = 0;
9896                 rsurface.modelvertex3f_bufferoffset = 0;
9897                 rsurface.modelsvector3f_bufferobject = 0;
9898                 rsurface.modelsvector3f_bufferoffset = 0;
9899                 rsurface.modeltvector3f_bufferobject = 0;
9900                 rsurface.modeltvector3f_bufferoffset = 0;
9901                 rsurface.modelnormal3f_bufferobject = 0;
9902                 rsurface.modelnormal3f_bufferoffset = 0;
9903                 rsurface.generatedvertex = true;
9904         }
9905         else
9906         {
9907                 rsurface.modelvertex3f  = model->surfmesh.data_vertex3f;
9908                 rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
9909                 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
9910                 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
9911                 rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
9912                 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
9913                 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
9914                 rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
9915                 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
9916                 rsurface.modelnormal3f  = model->surfmesh.data_normal3f;
9917                 rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
9918                 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
9919                 rsurface.generatedvertex = false;
9920         }
9921         rsurface.modellightmapcolor4f  = model->surfmesh.data_lightmapcolor4f;
9922         rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
9923         rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
9924         rsurface.modeltexcoordtexture2f  = model->surfmesh.data_texcoordtexture2f;
9925         rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
9926         rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
9927         rsurface.modeltexcoordlightmap2f  = model->surfmesh.data_texcoordlightmap2f;
9928         rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
9929         rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
9930         rsurface.modelelement3i = model->surfmesh.data_element3i;
9931         rsurface.modelelement3s = model->surfmesh.data_element3s;
9932         rsurface.modelelement3i_bufferobject = model->surfmesh.ebo3i;
9933         rsurface.modelelement3s_bufferobject = model->surfmesh.ebo3s;
9934         rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
9935         rsurface.modelnum_vertices = model->surfmesh.num_vertices;
9936         rsurface.modelnum_triangles = model->surfmesh.num_triangles;
9937         rsurface.modelsurfaces = model->data_surfaces;
9938         rsurface.vertex3f  = rsurface.modelvertex3f;
9939         rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
9940         rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
9941         rsurface.svector3f = rsurface.modelsvector3f;
9942         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
9943         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
9944         rsurface.tvector3f = rsurface.modeltvector3f;
9945         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
9946         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
9947         rsurface.normal3f  = rsurface.modelnormal3f;
9948         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
9949         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
9950         rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
9951 }
9952
9953 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)
9954 {
9955         rsurface.entity = r_refdef.scene.worldentity;
9956         rsurface.skeleton = NULL;
9957         rsurface.ent_skinnum = 0;
9958         rsurface.ent_qwskin = -1;
9959         rsurface.ent_shadertime = shadertime;
9960         rsurface.ent_flags = entflags;
9961         rsurface.modelnum_vertices = numvertices;
9962         rsurface.modelnum_triangles = numtriangles;
9963         if (rsurface.array_size < rsurface.modelnum_vertices)
9964                 R_Mesh_ResizeArrays(rsurface.modelnum_vertices);
9965         rsurface.matrix = *matrix;
9966         rsurface.inversematrix = *inversematrix;
9967         rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
9968         rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
9969         R_EntityMatrix(&rsurface.matrix);
9970         Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
9971         Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
9972         rsurface.fogplaneviewdist *= rsurface.inversematrixscale;
9973         rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
9974         rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
9975         rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
9976         VectorSet(rsurface.modellight_ambient, 0, 0, 0);
9977         VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
9978         VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
9979         VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
9980         VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
9981         Vector4Set(rsurface.colormod, r * r_refdef.view.colorscale, g * r_refdef.view.colorscale, b * r_refdef.view.colorscale, a);
9982         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);
9983         memset(rsurface.frameblend, 0, sizeof(rsurface.frameblend));
9984         rsurface.frameblend[0].lerp = 1;
9985         rsurface.ent_alttextures = false;
9986         rsurface.basepolygonfactor = r_refdef.polygonfactor;
9987         rsurface.basepolygonoffset = r_refdef.polygonoffset;
9988         if (wanttangents)
9989         {
9990                 rsurface.modelvertex3f = vertex3f;
9991                 rsurface.modelsvector3f = svector3f ? svector3f : rsurface.array_modelsvector3f;
9992                 rsurface.modeltvector3f = tvector3f ? tvector3f : rsurface.array_modeltvector3f;
9993                 rsurface.modelnormal3f = normal3f ? normal3f : rsurface.array_modelnormal3f;
9994         }
9995         else if (wantnormals)
9996         {
9997                 rsurface.modelvertex3f = vertex3f;
9998                 rsurface.modelsvector3f = NULL;
9999                 rsurface.modeltvector3f = NULL;
10000                 rsurface.modelnormal3f = normal3f ? normal3f : rsurface.array_modelnormal3f;
10001         }
10002         else
10003         {
10004                 rsurface.modelvertex3f = vertex3f;
10005                 rsurface.modelsvector3f = NULL;
10006                 rsurface.modeltvector3f = NULL;
10007                 rsurface.modelnormal3f = NULL;
10008         }
10009         rsurface.modelvertex3f_bufferobject = 0;
10010         rsurface.modelvertex3f_bufferoffset = 0;
10011         rsurface.modelsvector3f_bufferobject = 0;
10012         rsurface.modelsvector3f_bufferoffset = 0;
10013         rsurface.modeltvector3f_bufferobject = 0;
10014         rsurface.modeltvector3f_bufferoffset = 0;
10015         rsurface.modelnormal3f_bufferobject = 0;
10016         rsurface.modelnormal3f_bufferoffset = 0;
10017         rsurface.generatedvertex = true;
10018         rsurface.modellightmapcolor4f  = color4f;
10019         rsurface.modellightmapcolor4f_bufferobject = 0;
10020         rsurface.modellightmapcolor4f_bufferoffset = 0;
10021         rsurface.modeltexcoordtexture2f  = texcoord2f;
10022         rsurface.modeltexcoordtexture2f_bufferobject = 0;
10023         rsurface.modeltexcoordtexture2f_bufferoffset = 0;
10024         rsurface.modeltexcoordlightmap2f  = NULL;
10025         rsurface.modeltexcoordlightmap2f_bufferobject = 0;
10026         rsurface.modeltexcoordlightmap2f_bufferoffset = 0;
10027         rsurface.modelelement3i = element3i;
10028         rsurface.modelelement3s = element3s;
10029         rsurface.modelelement3i_bufferobject = 0;
10030         rsurface.modelelement3s_bufferobject = 0;
10031         rsurface.modellightmapoffsets = NULL;
10032         rsurface.modelsurfaces = NULL;
10033         rsurface.vertex3f  = rsurface.modelvertex3f;
10034         rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
10035         rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
10036         rsurface.svector3f = rsurface.modelsvector3f;
10037         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
10038         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
10039         rsurface.tvector3f = rsurface.modeltvector3f;
10040         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
10041         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
10042         rsurface.normal3f  = rsurface.modelnormal3f;
10043         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
10044         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
10045         rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
10046
10047         if (rsurface.modelnum_vertices && rsurface.modelelement3i)
10048         {
10049                 if ((wantnormals || wanttangents) && !normal3f)
10050                         Mod_BuildNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer != 0);
10051                 if (wanttangents && !svector3f)
10052                         Mod_BuildTextureVectorsFromNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modeltexcoordtexture2f, rsurface.modelnormal3f, rsurface.modelelement3i, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f, r_smoothnormals_areaweighting.integer != 0);
10053         }
10054 }
10055
10056 float RSurf_FogPoint(const float *v)
10057 {
10058         // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
10059         float FogPlaneViewDist = r_refdef.fogplaneviewdist;
10060         float FogPlaneVertexDist = DotProduct(r_refdef.fogplane, v) + r_refdef.fogplane[3];
10061         float FogHeightFade = r_refdef.fogheightfade;
10062         float fogfrac;
10063         unsigned int fogmasktableindex;
10064         if (r_refdef.fogplaneviewabove)
10065                 fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
10066         else
10067                 fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
10068         fogmasktableindex = (unsigned int)(VectorDistance(r_refdef.view.origin, v) * fogfrac * r_refdef.fogmasktabledistmultiplier);
10069         return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
10070 }
10071
10072 float RSurf_FogVertex(const float *v)
10073 {
10074         // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
10075         float FogPlaneViewDist = rsurface.fogplaneviewdist;
10076         float FogPlaneVertexDist = DotProduct(rsurface.fogplane, v) + rsurface.fogplane[3];
10077         float FogHeightFade = rsurface.fogheightfade;
10078         float fogfrac;
10079         unsigned int fogmasktableindex;
10080         if (r_refdef.fogplaneviewabove)
10081                 fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
10082         else
10083                 fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
10084         fogmasktableindex = (unsigned int)(VectorDistance(rsurface.localvieworigin, v) * fogfrac * rsurface.fogmasktabledistmultiplier);
10085         return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
10086 }
10087
10088 static const int quadedges[6][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}};
10089 void RSurf_PrepareVerticesForBatch(qboolean generatenormals, qboolean generatetangents, int texturenumsurfaces, const msurface_t **texturesurfacelist)
10090 {
10091         int deformindex;
10092         int texturesurfaceindex;
10093         int i, j;
10094         float amplitude;
10095         float animpos;
10096         float scale;
10097         const float *v1, *in_tc;
10098         float *out_tc;
10099         float center[3], forward[3], right[3], up[3], v[3], newforward[3], newright[3], newup[3];
10100         float waveparms[4];
10101         q3shaderinfo_deform_t *deform;
10102         // if vertices are dynamic (animated models), generate them into the temporary rsurface.array_model* arrays and point rsurface.model* at them instead of the static data from the model itself
10103         if (rsurface.generatedvertex)
10104         {
10105                 if (rsurface.texture->tcgen.tcgen == Q3TCGEN_ENVIRONMENT)
10106                         generatenormals = true;
10107                 for (i = 0;i < Q3MAXDEFORMS;i++)
10108                 {
10109                         if (rsurface.texture->deforms[i].deform == Q3DEFORM_AUTOSPRITE)
10110                         {
10111                                 generatetangents = true;
10112                                 generatenormals = true;
10113                         }
10114                         if (rsurface.texture->deforms[i].deform != Q3DEFORM_NONE)
10115                                 generatenormals = true;
10116                 }
10117                 if (generatenormals && !rsurface.modelnormal3f)
10118                 {
10119                         rsurface.normal3f = rsurface.modelnormal3f = rsurface.array_modelnormal3f;
10120                         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject = 0;
10121                         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset = 0;
10122                         Mod_BuildNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer != 0);
10123                 }
10124                 if (generatetangents && !rsurface.modelsvector3f)
10125                 {
10126                         rsurface.svector3f = rsurface.modelsvector3f = rsurface.array_modelsvector3f;
10127                         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject = 0;
10128                         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset = 0;
10129                         rsurface.tvector3f = rsurface.modeltvector3f = rsurface.array_modeltvector3f;
10130                         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject = 0;
10131                         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset = 0;
10132                         Mod_BuildTextureVectorsFromNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modeltexcoordtexture2f, rsurface.modelnormal3f, rsurface.modelelement3i, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f, r_smoothnormals_areaweighting.integer != 0);
10133                 }
10134         }
10135         rsurface.vertex3f  = rsurface.modelvertex3f;
10136         rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
10137         rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
10138         rsurface.svector3f = rsurface.modelsvector3f;
10139         rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
10140         rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
10141         rsurface.tvector3f = rsurface.modeltvector3f;
10142         rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
10143         rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
10144         rsurface.normal3f  = rsurface.modelnormal3f;
10145         rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
10146         rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
10147         // if vertices are deformed (sprite flares and things in maps, possibly
10148         // water waves, bulges and other deformations), generate them into
10149         // rsurface.deform* arrays from whatever the rsurface.* arrays point to
10150         // (may be static model data or generated data for an animated model, or
10151         //  the previous deform pass)
10152         for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform;deformindex++, deform++)
10153         {
10154                 switch (deform->deform)
10155                 {
10156                 default:
10157                 case Q3DEFORM_PROJECTIONSHADOW:
10158                 case Q3DEFORM_TEXT0:
10159                 case Q3DEFORM_TEXT1:
10160                 case Q3DEFORM_TEXT2:
10161                 case Q3DEFORM_TEXT3:
10162                 case Q3DEFORM_TEXT4:
10163                 case Q3DEFORM_TEXT5:
10164                 case Q3DEFORM_TEXT6:
10165                 case Q3DEFORM_TEXT7:
10166                 case Q3DEFORM_NONE:
10167                         break;
10168                 case Q3DEFORM_AUTOSPRITE:
10169                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
10170                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
10171                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
10172                         VectorNormalize(newforward);
10173                         VectorNormalize(newright);
10174                         VectorNormalize(newup);
10175                         // make deformed versions of only the model vertices used by the specified surfaces
10176                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10177                         {
10178                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10179                                 // a single autosprite surface can contain multiple sprites...
10180                                 for (j = 0;j < surface->num_vertices - 3;j += 4)
10181                                 {
10182                                         VectorClear(center);
10183                                         for (i = 0;i < 4;i++)
10184                                                 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
10185                                         VectorScale(center, 0.25f, center);
10186                                         VectorCopy((rsurface.normal3f  + 3 * surface->num_firstvertex) + j*3, forward);
10187                                         VectorCopy((rsurface.svector3f + 3 * surface->num_firstvertex) + j*3, right);
10188                                         VectorCopy((rsurface.tvector3f + 3 * surface->num_firstvertex) + j*3, up);
10189                                         for (i = 0;i < 4;i++)
10190                                         {
10191                                                 VectorSubtract((rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i)*3, center, v);
10192                                                 VectorMAMAMAM(1, center, DotProduct(forward, v), newforward, DotProduct(right, v), newright, DotProduct(up, v), newup, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
10193                                         }
10194                                 }
10195                                 Mod_BuildNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformednormal3f, r_smoothnormals_areaweighting.integer != 0);
10196                                 Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modeltexcoordtexture2f, rsurface.array_deformednormal3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformedsvector3f, rsurface.array_deformedtvector3f, r_smoothnormals_areaweighting.integer != 0);
10197                         }
10198                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
10199                         rsurface.vertex3f_bufferobject = 0;
10200                         rsurface.vertex3f_bufferoffset = 0;
10201                         rsurface.svector3f = rsurface.array_deformedsvector3f;
10202                         rsurface.svector3f_bufferobject = 0;
10203                         rsurface.svector3f_bufferoffset = 0;
10204                         rsurface.tvector3f = rsurface.array_deformedtvector3f;
10205                         rsurface.tvector3f_bufferobject = 0;
10206                         rsurface.tvector3f_bufferoffset = 0;
10207                         rsurface.normal3f = rsurface.array_deformednormal3f;
10208                         rsurface.normal3f_bufferobject = 0;
10209                         rsurface.normal3f_bufferoffset = 0;
10210                         break;
10211                 case Q3DEFORM_AUTOSPRITE2:
10212                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
10213                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
10214                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
10215                         VectorNormalize(newforward);
10216                         VectorNormalize(newright);
10217                         VectorNormalize(newup);
10218                         // make deformed versions of only the model vertices used by the specified surfaces
10219                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10220                         {
10221                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10222                                 const float *v1, *v2;
10223                                 vec3_t start, end;
10224                                 float f, l;
10225                                 struct
10226                                 {
10227                                         float length2;
10228                                         const float *v1;
10229                                         const float *v2;
10230                                 }
10231                                 shortest[2];
10232                                 memset(shortest, 0, sizeof(shortest));
10233                                 // a single autosprite surface can contain multiple sprites...
10234                                 for (j = 0;j < surface->num_vertices - 3;j += 4)
10235                                 {
10236                                         VectorClear(center);
10237                                         for (i = 0;i < 4;i++)
10238                                                 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
10239                                         VectorScale(center, 0.25f, center);
10240                                         // find the two shortest edges, then use them to define the
10241                                         // axis vectors for rotating around the central axis
10242                                         for (i = 0;i < 6;i++)
10243                                         {
10244                                                 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][0]);
10245                                                 v2 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][1]);
10246 #if 0
10247                                                 Debug_PolygonBegin(NULL, 0);
10248                                                 Debug_PolygonVertex(v1[0], v1[1], v1[2], 0, 0, 1, 0, 0, 1);
10249                                                 Debug_PolygonVertex((v1[0] + v2[0]) * 0.5f + rsurface.normal3f[3 * (surface->num_firstvertex + j)+0] * 4, (v1[1] + v2[1]) * 0.5f + rsurface.normal3f[3 * (surface->num_firstvertex + j)+1], (v1[2] + v2[2]) * 0.5f + rsurface.normal3f[3 * (surface->num_firstvertex + j)+2], 0, 0, 1, 1, 0, 1);
10250                                                 Debug_PolygonVertex(v2[0], v2[1], v2[2], 0, 0, 1, 0, 0, 1);
10251                                                 Debug_PolygonEnd();
10252 #endif
10253                                                 l = VectorDistance2(v1, v2);
10254                                                 // this length bias tries to make sense of square polygons, assuming they are meant to be upright
10255                                                 if (v1[2] != v2[2])
10256                                                         l += (1.0f / 1024.0f);
10257                                                 if (shortest[0].length2 > l || i == 0)
10258                                                 {
10259                                                         shortest[1] = shortest[0];
10260                                                         shortest[0].length2 = l;
10261                                                         shortest[0].v1 = v1;
10262                                                         shortest[0].v2 = v2;
10263                                                 }
10264                                                 else if (shortest[1].length2 > l || i == 1)
10265                                                 {
10266                                                         shortest[1].length2 = l;
10267                                                         shortest[1].v1 = v1;
10268                                                         shortest[1].v2 = v2;
10269                                                 }
10270                                         }
10271                                         VectorLerp(shortest[0].v1, 0.5f, shortest[0].v2, start);
10272                                         VectorLerp(shortest[1].v1, 0.5f, shortest[1].v2, end);
10273 #if 0
10274                                         Debug_PolygonBegin(NULL, 0);
10275                                         Debug_PolygonVertex(start[0], start[1], start[2], 0, 0, 1, 1, 0, 1);
10276                                         Debug_PolygonVertex(center[0] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+0] * 4, center[1] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+1] * 4, center[2] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+2] * 4, 0, 0, 0, 1, 0, 1);
10277                                         Debug_PolygonVertex(end[0], end[1], end[2], 0, 0, 0, 1, 1, 1);
10278                                         Debug_PolygonEnd();
10279 #endif
10280                                         // this calculates the right vector from the shortest edge
10281                                         // and the up vector from the edge midpoints
10282                                         VectorSubtract(shortest[0].v1, shortest[0].v2, right);
10283                                         VectorNormalize(right);
10284                                         VectorSubtract(end, start, up);
10285                                         VectorNormalize(up);
10286                                         // calculate a forward vector to use instead of the original plane normal (this is how we get a new right vector)
10287                                         VectorSubtract(rsurface.localvieworigin, center, forward);
10288                                         //Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, forward);
10289                                         VectorNegate(forward, forward);
10290                                         VectorReflect(forward, 0, up, forward);
10291                                         VectorNormalize(forward);
10292                                         CrossProduct(up, forward, newright);
10293                                         VectorNormalize(newright);
10294 #if 0
10295                                         Debug_PolygonBegin(NULL, 0);
10296                                         Debug_PolygonVertex(center[0] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+0] * 8, center[1] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+1] * 8, center[2] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+2] * 8, 0, 0, 1, 0, 0, 1);
10297                                         Debug_PolygonVertex(center[0] + right[0] * 8, center[1] + right[1] * 8, center[2] + right[2] * 8, 0, 0, 0, 1, 0, 1);
10298                                         Debug_PolygonVertex(center[0] + up   [0] * 8, center[1] + up   [1] * 8, center[2] + up   [2] * 8, 0, 0, 0, 0, 1, 1);
10299                                         Debug_PolygonEnd();
10300 #endif
10301 #if 0
10302                                         Debug_PolygonBegin(NULL, 0);
10303                                         Debug_PolygonVertex(center[0] + forward [0] * 8, center[1] + forward [1] * 8, center[2] + forward [2] * 8, 0, 0, 1, 0, 0, 1);
10304                                         Debug_PolygonVertex(center[0] + newright[0] * 8, center[1] + newright[1] * 8, center[2] + newright[2] * 8, 0, 0, 0, 1, 0, 1);
10305                                         Debug_PolygonVertex(center[0] + up      [0] * 8, center[1] + up      [1] * 8, center[2] + up      [2] * 8, 0, 0, 0, 0, 1, 1);
10306                                         Debug_PolygonEnd();
10307 #endif
10308                                         // rotate the quad around the up axis vector, this is made
10309                                         // especially easy by the fact we know the quad is flat,
10310                                         // so we only have to subtract the center position and
10311                                         // measure distance along the right vector, and then
10312                                         // multiply that by the newright vector and add back the
10313                                         // center position
10314                                         // we also need to subtract the old position to undo the
10315                                         // displacement from the center, which we do with a
10316                                         // DotProduct, the subtraction/addition of center is also
10317                                         // optimized into DotProducts here
10318                                         l = DotProduct(right, center);
10319                                         for (i = 0;i < 4;i++)
10320                                         {
10321                                                 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + j + i);
10322                                                 f = DotProduct(right, v1) - l;
10323                                                 VectorMAMAM(1, v1, -f, right, f, newright, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
10324                                         }
10325                                 }
10326                                 Mod_BuildNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformednormal3f, r_smoothnormals_areaweighting.integer != 0);
10327                                 Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modeltexcoordtexture2f, rsurface.array_deformednormal3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformedsvector3f, rsurface.array_deformedtvector3f, r_smoothnormals_areaweighting.integer != 0);
10328                         }
10329                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
10330                         rsurface.vertex3f_bufferobject = 0;
10331                         rsurface.vertex3f_bufferoffset = 0;
10332                         rsurface.svector3f = rsurface.array_deformedsvector3f;
10333                         rsurface.svector3f_bufferobject = 0;
10334                         rsurface.svector3f_bufferoffset = 0;
10335                         rsurface.tvector3f = rsurface.array_deformedtvector3f;
10336                         rsurface.tvector3f_bufferobject = 0;
10337                         rsurface.tvector3f_bufferoffset = 0;
10338                         rsurface.normal3f = rsurface.array_deformednormal3f;
10339                         rsurface.normal3f_bufferobject = 0;
10340                         rsurface.normal3f_bufferoffset = 0;
10341                         break;
10342                 case Q3DEFORM_NORMAL:
10343                         // deform the normals to make reflections wavey
10344                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10345                         {
10346                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10347                                 for (j = 0;j < surface->num_vertices;j++)
10348                                 {
10349                                         float vertex[3];
10350                                         float *normal = (rsurface.array_deformednormal3f  + 3 * surface->num_firstvertex) + j*3;
10351                                         VectorScale((rsurface.vertex3f  + 3 * surface->num_firstvertex) + j*3, 0.98f, vertex);
10352                                         VectorCopy((rsurface.normal3f  + 3 * surface->num_firstvertex) + j*3, normal);
10353                                         normal[0] += deform->parms[0] * noise4f(      vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
10354                                         normal[1] += deform->parms[0] * noise4f( 98 + vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
10355                                         normal[2] += deform->parms[0] * noise4f(196 + vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
10356                                         VectorNormalize(normal);
10357                                 }
10358                                 Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modeltexcoordtexture2f, rsurface.array_deformednormal3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformedsvector3f, rsurface.array_deformedtvector3f, r_smoothnormals_areaweighting.integer != 0);
10359                         }
10360                         rsurface.svector3f = rsurface.array_deformedsvector3f;
10361                         rsurface.svector3f_bufferobject = 0;
10362                         rsurface.svector3f_bufferoffset = 0;
10363                         rsurface.tvector3f = rsurface.array_deformedtvector3f;
10364                         rsurface.tvector3f_bufferobject = 0;
10365                         rsurface.tvector3f_bufferoffset = 0;
10366                         rsurface.normal3f = rsurface.array_deformednormal3f;
10367                         rsurface.normal3f_bufferobject = 0;
10368                         rsurface.normal3f_bufferoffset = 0;
10369                         break;
10370                 case Q3DEFORM_WAVE:
10371                         // deform vertex array to make wavey water and flags and such
10372                         waveparms[0] = deform->waveparms[0];
10373                         waveparms[1] = deform->waveparms[1];
10374                         waveparms[2] = deform->waveparms[2];
10375                         waveparms[3] = deform->waveparms[3];
10376                         if(!R_TestQ3WaveFunc(deform->wavefunc, waveparms))
10377                                 break; // if wavefunc is a nop, don't make a dynamic vertex array
10378                         // this is how a divisor of vertex influence on deformation
10379                         animpos = deform->parms[0] ? 1.0f / deform->parms[0] : 100.0f;
10380                         scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
10381                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10382                         {
10383                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10384                                 for (j = 0;j < surface->num_vertices;j++)
10385                                 {
10386                                         float *vertex = (rsurface.array_deformedvertex3f  + 3 * surface->num_firstvertex) + j*3;
10387                                         VectorCopy((rsurface.vertex3f  + 3 * surface->num_firstvertex) + j*3, vertex);
10388                                         // if the wavefunc depends on time, evaluate it per-vertex
10389                                         if (waveparms[3])
10390                                         {
10391                                                 waveparms[2] = deform->waveparms[2] + (vertex[0] + vertex[1] + vertex[2]) * animpos;
10392                                                 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
10393                                         }
10394                                         VectorMA(vertex, scale, (rsurface.normal3f  + 3 * surface->num_firstvertex) + j*3, vertex);
10395                                 }
10396                         }
10397                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
10398                         rsurface.vertex3f_bufferobject = 0;
10399                         rsurface.vertex3f_bufferoffset = 0;
10400                         break;
10401                 case Q3DEFORM_BULGE:
10402                         // deform vertex array to make the surface have moving bulges
10403                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10404                         {
10405                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10406                                 for (j = 0;j < surface->num_vertices;j++)
10407                                 {
10408                                         scale = sin((rsurface.modeltexcoordtexture2f[2 * (surface->num_firstvertex + j)] * deform->parms[0] + r_refdef.scene.time * deform->parms[2])) * deform->parms[1];
10409                                         VectorMA(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), scale, rsurface.normal3f + 3 * (surface->num_firstvertex + j), rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
10410                                 }
10411                         }
10412                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
10413                         rsurface.vertex3f_bufferobject = 0;
10414                         rsurface.vertex3f_bufferoffset = 0;
10415                         break;
10416                 case Q3DEFORM_MOVE:
10417                         // deform vertex array
10418                         if(!R_TestQ3WaveFunc(deform->wavefunc, deform->waveparms))
10419                                 break; // if wavefunc is a nop, don't make a dynamic vertex array
10420                         scale = R_EvaluateQ3WaveFunc(deform->wavefunc, deform->waveparms);
10421                         VectorScale(deform->parms, scale, waveparms);
10422                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10423                         {
10424                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10425                                 for (j = 0;j < surface->num_vertices;j++)
10426                                         VectorAdd(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), waveparms, rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
10427                         }
10428                         rsurface.vertex3f = rsurface.array_deformedvertex3f;
10429                         rsurface.vertex3f_bufferobject = 0;
10430                         rsurface.vertex3f_bufferoffset = 0;
10431                         break;
10432                 }
10433         }
10434         // generate texcoords based on the chosen texcoord source
10435         switch(rsurface.texture->tcgen.tcgen)
10436         {
10437         default:
10438         case Q3TCGEN_TEXTURE:
10439                 rsurface.texcoordtexture2f               = rsurface.modeltexcoordtexture2f;
10440                 rsurface.texcoordtexture2f_bufferobject  = rsurface.modeltexcoordtexture2f_bufferobject;
10441                 rsurface.texcoordtexture2f_bufferoffset  = rsurface.modeltexcoordtexture2f_bufferoffset;
10442                 break;
10443         case Q3TCGEN_LIGHTMAP:
10444                 rsurface.texcoordtexture2f               = rsurface.modeltexcoordlightmap2f;
10445                 rsurface.texcoordtexture2f_bufferobject  = rsurface.modeltexcoordlightmap2f_bufferobject;
10446                 rsurface.texcoordtexture2f_bufferoffset  = rsurface.modeltexcoordlightmap2f_bufferoffset;
10447                 break;
10448         case Q3TCGEN_VECTOR:
10449                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10450                 {
10451                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10452                         for (j = 0, v1 = rsurface.modelvertex3f + 3 * surface->num_firstvertex, out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;j < surface->num_vertices;j++, v1 += 3, out_tc += 2)
10453                         {
10454                                 out_tc[0] = DotProduct(v1, rsurface.texture->tcgen.parms);
10455                                 out_tc[1] = DotProduct(v1, rsurface.texture->tcgen.parms + 3);
10456                         }
10457                 }
10458                 rsurface.texcoordtexture2f               = rsurface.array_generatedtexcoordtexture2f;
10459                 rsurface.texcoordtexture2f_bufferobject  = 0;
10460                 rsurface.texcoordtexture2f_bufferoffset  = 0;
10461                 break;
10462         case Q3TCGEN_ENVIRONMENT:
10463                 // make environment reflections using a spheremap
10464                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10465                 {
10466                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10467                         const float *vertex = rsurface.modelvertex3f + 3 * surface->num_firstvertex;
10468                         const float *normal = rsurface.modelnormal3f + 3 * surface->num_firstvertex;
10469                         float *out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;
10470                         for (j = 0;j < surface->num_vertices;j++, vertex += 3, normal += 3, out_tc += 2)
10471                         {
10472                                 // identical to Q3A's method, but executed in worldspace so
10473                                 // carried models can be shiny too
10474
10475                                 float viewer[3], d, reflected[3], worldreflected[3];
10476
10477                                 VectorSubtract(rsurface.localvieworigin, vertex, viewer);
10478                                 // VectorNormalize(viewer);
10479
10480                                 d = DotProduct(normal, viewer);
10481
10482                                 reflected[0] = normal[0]*2*d - viewer[0];
10483                                 reflected[1] = normal[1]*2*d - viewer[1];
10484                                 reflected[2] = normal[2]*2*d - viewer[2];
10485                                 // note: this is proportinal to viewer, so we can normalize later
10486
10487                                 Matrix4x4_Transform3x3(&rsurface.matrix, reflected, worldreflected);
10488                                 VectorNormalize(worldreflected);
10489
10490                                 // note: this sphere map only uses world x and z!
10491                                 // so positive and negative y will LOOK THE SAME.
10492                                 out_tc[0] = 0.5 + 0.5 * worldreflected[1];
10493                                 out_tc[1] = 0.5 - 0.5 * worldreflected[2];
10494                         }
10495                 }
10496                 rsurface.texcoordtexture2f               = rsurface.array_generatedtexcoordtexture2f;
10497                 rsurface.texcoordtexture2f_bufferobject  = 0;
10498                 rsurface.texcoordtexture2f_bufferoffset  = 0;
10499                 break;
10500         }
10501         // the only tcmod that needs software vertex processing is turbulent, so
10502         // check for it here and apply the changes if needed
10503         // and we only support that as the first one
10504         // (handling a mixture of turbulent and other tcmods would be problematic
10505         //  without punting it entirely to a software path)
10506         if (rsurface.texture->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
10507         {
10508                 amplitude = rsurface.texture->tcmods[0].parms[1];
10509                 animpos = rsurface.texture->tcmods[0].parms[2] + r_refdef.scene.time * rsurface.texture->tcmods[0].parms[3];
10510                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10511                 {
10512                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10513                         for (j = 0, v1 = rsurface.modelvertex3f + 3 * surface->num_firstvertex, in_tc = rsurface.texcoordtexture2f + 2 * surface->num_firstvertex, out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;j < surface->num_vertices;j++, v1 += 3, in_tc += 2, out_tc += 2)
10514                         {
10515                                 out_tc[0] = in_tc[0] + amplitude * sin(((v1[0] + v1[2]) * 1.0 / 1024.0f + animpos) * M_PI * 2);
10516                                 out_tc[1] = in_tc[1] + amplitude * sin(((v1[1]        ) * 1.0 / 1024.0f + animpos) * M_PI * 2);
10517                         }
10518                 }
10519                 rsurface.texcoordtexture2f               = rsurface.array_generatedtexcoordtexture2f;
10520                 rsurface.texcoordtexture2f_bufferobject  = 0;
10521                 rsurface.texcoordtexture2f_bufferoffset  = 0;
10522         }
10523         rsurface.texcoordlightmap2f              = rsurface.modeltexcoordlightmap2f;
10524         rsurface.texcoordlightmap2f_bufferobject = rsurface.modeltexcoordlightmap2f_bufferobject;
10525         rsurface.texcoordlightmap2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
10526         R_Mesh_VertexPointer(rsurface.vertex3f, rsurface.vertex3f_bufferobject, rsurface.vertex3f_bufferoffset);
10527 }
10528
10529 void RSurf_DrawBatch_Simple(int texturenumsurfaces, const msurface_t **texturesurfacelist)
10530 {
10531         int i, j;
10532         const msurface_t *surface = texturesurfacelist[0];
10533         const msurface_t *surface2;
10534         int firstvertex;
10535         int endvertex;
10536         int numvertices;
10537         int numtriangles;
10538         // TODO: lock all array ranges before render, rather than on each surface
10539         if (texturenumsurfaces == 1)
10540                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
10541         else if (r_batchmode.integer == 2)
10542         {
10543                 #define MAXBATCHTRIANGLES 65536
10544                 int batchtriangles = 0;
10545                 static int batchelements[MAXBATCHTRIANGLES*3];
10546                 for (i = 0;i < texturenumsurfaces;i = j)
10547                 {
10548                         surface = texturesurfacelist[i];
10549                         j = i + 1;
10550                         if (surface->num_triangles > MAXBATCHTRIANGLES)
10551                         {
10552                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
10553                                 continue;
10554                         }
10555                         memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
10556                         batchtriangles = surface->num_triangles;
10557                         firstvertex = surface->num_firstvertex;
10558                         endvertex = surface->num_firstvertex + surface->num_vertices;
10559                         for (;j < texturenumsurfaces;j++)
10560                         {
10561                                 surface2 = texturesurfacelist[j];
10562                                 if (batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
10563                                         break;
10564                                 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
10565                                 batchtriangles += surface2->num_triangles;
10566                                 firstvertex = min(firstvertex, surface2->num_firstvertex);
10567                                 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
10568                         }
10569                         surface2 = texturesurfacelist[j-1];
10570                         numvertices = endvertex - firstvertex;
10571                         R_Mesh_Draw(firstvertex, numvertices, 0, batchtriangles, batchelements, NULL, 0, 0);
10572                 }
10573         }
10574         else if (r_batchmode.integer == 1)
10575         {
10576                 for (i = 0;i < texturenumsurfaces;i = j)
10577                 {
10578                         surface = texturesurfacelist[i];
10579                         for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
10580                                 if (texturesurfacelist[j] != surface2)
10581                                         break;
10582                         surface2 = texturesurfacelist[j-1];
10583                         numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
10584                         numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
10585                         R_Mesh_Draw(surface->num_firstvertex, numvertices, surface->num_firsttriangle, numtriangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
10586                 }
10587         }
10588         else
10589         {
10590                 for (i = 0;i < texturenumsurfaces;i++)
10591                 {
10592                         surface = texturesurfacelist[i];
10593                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
10594                 }
10595         }
10596 }
10597
10598 static void RSurf_BindLightmapForSurface(const msurface_t *surface)
10599 {
10600         switch(vid.renderpath)
10601         {
10602         case RENDERPATH_CGGL:
10603 #ifdef SUPPORTCG
10604                 if (r_cg_permutation->fp_Texture_Lightmap ) CG_BindTexture(r_cg_permutation->fp_Texture_Lightmap , surface->lightmaptexture );CHECKCGERROR
10605                 if (r_cg_permutation->fp_Texture_Deluxemap) CG_BindTexture(r_cg_permutation->fp_Texture_Deluxemap, surface->deluxemaptexture);CHECKCGERROR
10606 #endif
10607                 break;
10608         case RENDERPATH_GL20:
10609                 if (r_glsl_permutation->loc_Texture_Lightmap  >= 0) R_Mesh_TexBind(GL20TU_LIGHTMAP , surface->lightmaptexture );
10610                 if (r_glsl_permutation->loc_Texture_Deluxemap >= 0) R_Mesh_TexBind(GL20TU_DELUXEMAP, surface->deluxemaptexture);
10611                 break;
10612         case RENDERPATH_GL13:
10613         case RENDERPATH_GL11:
10614                 R_Mesh_TexBind(0, surface->lightmaptexture);
10615                 break;
10616         }
10617 }
10618
10619 static void RSurf_BindReflectionForSurface(const msurface_t *surface)
10620 {
10621         // pick the closest matching water plane and bind textures
10622         int planeindex, vertexindex;
10623         float d, bestd;
10624         vec3_t vert;
10625         const float *v;
10626         r_waterstate_waterplane_t *p, *bestp;
10627         bestd = 0;
10628         bestp = NULL;
10629         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
10630         {
10631                 if(p->camera_entity != rsurface.texture->camera_entity)
10632                         continue;
10633                 d = 0;
10634                 for (vertexindex = 0, v = rsurface.modelvertex3f + surface->num_firstvertex * 3;vertexindex < surface->num_vertices;vertexindex++, v += 3)
10635                 {
10636                         Matrix4x4_Transform(&rsurface.matrix, v, vert);
10637                         d += fabs(PlaneDiff(vert, &p->plane));
10638                 }
10639                 if (bestd > d || !bestp)
10640                 {
10641                         bestd = d;
10642                         bestp = p;
10643                 }
10644         }
10645         switch(vid.renderpath)
10646         {
10647         case RENDERPATH_CGGL:
10648 #ifdef SUPPORTCG
10649                 if (r_cg_permutation->fp_Texture_Refraction) {CG_BindTexture(r_cg_permutation->fp_Texture_Refraction, bestp ? bestp->texture_refraction : r_texture_black);CHECKCGERROR}
10650                 else if (r_cg_permutation->fp_Texture_First) {CG_BindTexture(r_cg_permutation->fp_Texture_First, bestp ? bestp->texture_camera : r_texture_black);CHECKCGERROR}
10651                 if (r_cg_permutation->fp_Texture_Reflection) {CG_BindTexture(r_cg_permutation->fp_Texture_Reflection, bestp ? bestp->texture_reflection : r_texture_black);CHECKCGERROR}
10652 #endif
10653                 break;
10654         case RENDERPATH_GL20:
10655                 if (r_glsl_permutation->loc_Texture_Refraction >= 0) R_Mesh_TexBind(GL20TU_REFRACTION, bestp ? bestp->texture_refraction : r_texture_black);
10656                 else if (r_glsl_permutation->loc_Texture_First >= 0) R_Mesh_TexBind(GL20TU_FIRST, bestp ? bestp->texture_camera : r_texture_black);
10657                 if (r_glsl_permutation->loc_Texture_Reflection >= 0) R_Mesh_TexBind(GL20TU_REFLECTION, bestp ? bestp->texture_reflection : r_texture_black);
10658                 break;
10659         case RENDERPATH_GL13:
10660         case RENDERPATH_GL11:
10661                 break;
10662         }
10663 }
10664
10665 static void RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(int texturenumsurfaces, const msurface_t **texturesurfacelist)
10666 {
10667         int i;
10668         const msurface_t *surface;
10669         if (r_waterstate.renderingscene)
10670                 return;
10671         for (i = 0;i < texturenumsurfaces;i++)
10672         {
10673                 surface = texturesurfacelist[i];
10674                 RSurf_BindLightmapForSurface(surface);
10675                 RSurf_BindReflectionForSurface(surface);
10676                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
10677         }
10678 }
10679
10680 static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, const msurface_t **texturesurfacelist)
10681 {
10682         int i;
10683         int j;
10684         const msurface_t *surface = texturesurfacelist[0];
10685         const msurface_t *surface2;
10686         int firstvertex;
10687         int endvertex;
10688         int numvertices;
10689         int numtriangles;
10690         if (texturenumsurfaces == 1)
10691         {
10692                 RSurf_BindLightmapForSurface(surface);
10693                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
10694         }
10695         else if (r_batchmode.integer == 2)
10696         {
10697                 int batchtriangles = 0;
10698                 static int batchelements[MAXBATCHTRIANGLES*3];
10699                 for (i = 0;i < texturenumsurfaces;i = j)
10700                 {
10701                         surface = texturesurfacelist[i];
10702                         RSurf_BindLightmapForSurface(surface);
10703                         j = i + 1;
10704                         if (surface->num_triangles > MAXBATCHTRIANGLES)
10705                         {
10706                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
10707                                 continue;
10708                         }
10709                         memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
10710                         batchtriangles = surface->num_triangles;
10711                         firstvertex = surface->num_firstvertex;
10712                         endvertex = surface->num_firstvertex + surface->num_vertices;
10713                         for (;j < texturenumsurfaces;j++)
10714                         {
10715                                 surface2 = texturesurfacelist[j];
10716                                 if (surface2->lightmaptexture != surface->lightmaptexture || batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
10717                                         break;
10718                                 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
10719                                 batchtriangles += surface2->num_triangles;
10720                                 firstvertex = min(firstvertex, surface2->num_firstvertex);
10721                                 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
10722                         }
10723                         surface2 = texturesurfacelist[j-1];
10724                         numvertices = endvertex - firstvertex;
10725                         R_Mesh_Draw(firstvertex, numvertices, 0, batchtriangles, batchelements, NULL, 0, 0);
10726                 }
10727         }
10728         else if (r_batchmode.integer == 1)
10729         {
10730 #if 0
10731                 Con_Printf("%s batch sizes ignoring lightmap:", rsurface.texture->name);
10732                 for (i = 0;i < texturenumsurfaces;i = j)
10733                 {
10734                         surface = texturesurfacelist[i];
10735                         for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
10736                                 if (texturesurfacelist[j] != surface2)
10737                                         break;
10738                         Con_Printf(" %i", j - i);
10739                 }
10740                 Con_Printf("\n");
10741                 Con_Printf("%s batch sizes honoring lightmap:", rsurface.texture->name);
10742 #endif
10743                 for (i = 0;i < texturenumsurfaces;i = j)
10744                 {
10745                         surface = texturesurfacelist[i];
10746                         RSurf_BindLightmapForSurface(surface);
10747                         for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
10748                                 if (texturesurfacelist[j] != surface2 || texturesurfacelist[j]->lightmaptexture != surface->lightmaptexture)
10749                                         break;
10750 #if 0
10751                         Con_Printf(" %i", j - i);
10752 #endif
10753                         surface2 = texturesurfacelist[j-1];
10754                         numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
10755                         numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
10756                         R_Mesh_Draw(surface->num_firstvertex, numvertices, surface->num_firsttriangle, numtriangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
10757                 }
10758 #if 0
10759                 Con_Printf("\n");
10760 #endif
10761         }
10762         else
10763         {
10764                 for (i = 0;i < texturenumsurfaces;i++)
10765                 {
10766                         surface = texturesurfacelist[i];
10767                         RSurf_BindLightmapForSurface(surface);
10768                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
10769                 }
10770         }
10771 }
10772
10773 static void RSurf_DrawBatch_ShowSurfaces(int texturenumsurfaces, const msurface_t **texturesurfacelist)
10774 {
10775         int j;
10776         int texturesurfaceindex;
10777         if (r_showsurfaces.integer == 2)
10778         {
10779                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10780                 {
10781                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10782                         for (j = 0;j < surface->num_triangles;j++)
10783                         {
10784                                 float f = ((j + surface->num_firsttriangle) & 31) * (1.0f / 31.0f) * r_refdef.view.colorscale;
10785                                 GL_Color(f, f, f, 1);
10786                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle + j, 1, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
10787                         }
10788                 }
10789         }
10790         else
10791         {
10792                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10793                 {
10794                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10795                         int k = (int)(((size_t)surface) / sizeof(msurface_t));
10796                         GL_Color((k & 15) * (1.0f / 16.0f) * r_refdef.view.colorscale, ((k >> 4) & 15) * (1.0f / 16.0f) * r_refdef.view.colorscale, ((k >> 8) & 15) * (1.0f / 16.0f) * r_refdef.view.colorscale, 1);
10797                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
10798                 }
10799         }
10800 }
10801
10802 static void RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray(int texturenumsurfaces, const msurface_t **texturesurfacelist)
10803 {
10804         int texturesurfaceindex;
10805         int i;
10806         const float *v;
10807         float *c2;
10808         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10809         {
10810                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10811                 for (i = 0, v = (rsurface.vertex3f + 3 * surface->num_firstvertex), c2 = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c2 += 4)
10812                 {
10813                         c2[0] = 0.5;
10814                         c2[1] = 0.5;
10815                         c2[2] = 0.5;
10816                         c2[3] = 1;
10817                 }
10818         }
10819         rsurface.lightmapcolor4f = rsurface.array_color4f;
10820         rsurface.lightmapcolor4f_bufferobject = 0;
10821         rsurface.lightmapcolor4f_bufferoffset = 0;
10822 }
10823
10824 static void RSurf_DrawBatch_GL11_ApplyFog(int texturenumsurfaces, const msurface_t **texturesurfacelist)
10825 {
10826         int texturesurfaceindex;
10827         int i;
10828         float f;
10829         const float *v;
10830         const float *c;
10831         float *c2;
10832         if (rsurface.lightmapcolor4f)
10833         {
10834                 // generate color arrays for the surfaces in this list
10835                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10836                 {
10837                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10838                         for (i = 0, v = (rsurface.vertex3f + 3 * surface->num_firstvertex), c = (rsurface.lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4, c2 += 4)
10839                         {
10840                                 f = RSurf_FogVertex(v);
10841                                 c2[0] = c[0] * f;
10842                                 c2[1] = c[1] * f;
10843                                 c2[2] = c[2] * f;
10844                                 c2[3] = c[3];
10845                         }
10846                 }
10847         }
10848         else
10849         {
10850                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10851                 {
10852                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10853                         for (i = 0, v = (rsurface.vertex3f + 3 * surface->num_firstvertex), c2 = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c2 += 4)
10854                         {
10855                                 f = RSurf_FogVertex(v);
10856                                 c2[0] = f;
10857                                 c2[1] = f;
10858                                 c2[2] = f;
10859                                 c2[3] = 1;
10860                         }
10861                 }
10862         }
10863         rsurface.lightmapcolor4f = rsurface.array_color4f;
10864         rsurface.lightmapcolor4f_bufferobject = 0;
10865         rsurface.lightmapcolor4f_bufferoffset = 0;
10866 }
10867
10868 static void RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors(int texturenumsurfaces, const msurface_t **texturesurfacelist)
10869 {
10870         int texturesurfaceindex;
10871         int i;
10872         float f;
10873         const float *v;
10874         const float *c;
10875         float *c2;
10876         if (!rsurface.lightmapcolor4f)
10877                 return;
10878         // generate color arrays for the surfaces in this list
10879         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10880         {
10881                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10882                 for (i = 0, v = (rsurface.vertex3f + 3 * surface->num_firstvertex), c = (rsurface.lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4, c2 += 4)
10883                 {
10884                         f = RSurf_FogVertex(v);
10885                         c2[0] = c[0] * f + r_refdef.fogcolor[0] * (1 - f);
10886                         c2[1] = c[1] * f + r_refdef.fogcolor[1] * (1 - f);
10887                         c2[2] = c[2] * f + r_refdef.fogcolor[2] * (1 - f);
10888                         c2[3] = c[3];
10889                 }
10890         }
10891         rsurface.lightmapcolor4f = rsurface.array_color4f;
10892         rsurface.lightmapcolor4f_bufferobject = 0;
10893         rsurface.lightmapcolor4f_bufferoffset = 0;
10894 }
10895
10896 static void RSurf_DrawBatch_GL11_ApplyColor(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a)
10897 {
10898         int texturesurfaceindex;
10899         int i;
10900         const float *c;
10901         float *c2;
10902         if (!rsurface.lightmapcolor4f)
10903                 return;
10904         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10905         {
10906                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10907                 for (i = 0, c = (rsurface.lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, c += 4, c2 += 4)
10908                 {
10909                         c2[0] = c[0] * r;
10910                         c2[1] = c[1] * g;
10911                         c2[2] = c[2] * b;
10912                         c2[3] = c[3] * a;
10913                 }
10914         }
10915         rsurface.lightmapcolor4f = rsurface.array_color4f;
10916         rsurface.lightmapcolor4f_bufferobject = 0;
10917         rsurface.lightmapcolor4f_bufferoffset = 0;
10918 }
10919
10920 static void RSurf_DrawBatch_GL11_ApplyAmbient(int texturenumsurfaces, const msurface_t **texturesurfacelist)
10921 {
10922         int texturesurfaceindex;
10923         int i;
10924         const float *c;
10925         float *c2;
10926         if (!rsurface.lightmapcolor4f)
10927                 return;
10928         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10929         {
10930                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10931                 for (i = 0, c = (rsurface.lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, c += 4, c2 += 4)
10932                 {
10933                         c2[0] = c[0] + r_refdef.scene.ambient;
10934                         c2[1] = c[1] + r_refdef.scene.ambient;
10935                         c2[2] = c[2] + r_refdef.scene.ambient;
10936                         c2[3] = c[3];
10937                 }
10938         }
10939         rsurface.lightmapcolor4f = rsurface.array_color4f;
10940         rsurface.lightmapcolor4f_bufferobject = 0;
10941         rsurface.lightmapcolor4f_bufferoffset = 0;
10942 }
10943
10944 static void RSurf_DrawBatch_GL11_Lightmap(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
10945 {
10946         // TODO: optimize
10947         rsurface.lightmapcolor4f = NULL;
10948         rsurface.lightmapcolor4f_bufferobject = 0;
10949         rsurface.lightmapcolor4f_bufferoffset = 0;
10950         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
10951         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
10952         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
10953         GL_Color(r, g, b, a);
10954         RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist);
10955 }
10956
10957 static void RSurf_DrawBatch_GL11_Unlit(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
10958 {
10959         // TODO: optimize applyfog && applycolor case
10960         // just apply fog if necessary, and tint the fog color array if necessary
10961         rsurface.lightmapcolor4f = NULL;
10962         rsurface.lightmapcolor4f_bufferobject = 0;
10963         rsurface.lightmapcolor4f_bufferoffset = 0;
10964         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
10965         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
10966         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
10967         GL_Color(r, g, b, a);
10968         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
10969 }
10970
10971 static void RSurf_DrawBatch_GL11_VertexColor(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
10972 {
10973         int texturesurfaceindex;
10974         int i;
10975         float *c;
10976         // TODO: optimize
10977         if (texturesurfacelist[0]->lightmapinfo)
10978         {
10979                 // generate color arrays for the surfaces in this list
10980                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10981                 {
10982                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
10983                         for (i = 0, c = rsurface.array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
10984                         {
10985                                 if (surface->lightmapinfo->samples)
10986                                 {
10987                                         const unsigned char *lm = surface->lightmapinfo->samples + (rsurface.modellightmapoffsets + surface->num_firstvertex)[i];
10988                                         float scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[0]] * (1.0f / 32768.0f);
10989                                         VectorScale(lm, scale, c);
10990                                         if (surface->lightmapinfo->styles[1] != 255)
10991                                         {
10992                                                 int size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
10993                                                 lm += size3;
10994                                                 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[1]] * (1.0f / 32768.0f);
10995                                                 VectorMA(c, scale, lm, c);
10996                                                 if (surface->lightmapinfo->styles[2] != 255)
10997                                                 {
10998                                                         lm += size3;
10999                                                         scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[2]] * (1.0f / 32768.0f);
11000                                                         VectorMA(c, scale, lm, c);
11001                                                         if (surface->lightmapinfo->styles[3] != 255)
11002                                                         {
11003                                                                 lm += size3;
11004                                                                 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[3]] * (1.0f / 32768.0f);
11005                                                                 VectorMA(c, scale, lm, c);
11006                                                         }
11007                                                 }
11008                                         }
11009                                 }
11010                                 else
11011                                         VectorClear(c);
11012                                 c[3] = 1;
11013                         }
11014                 }
11015                 rsurface.lightmapcolor4f = rsurface.array_color4f;
11016                 rsurface.lightmapcolor4f_bufferobject = 0;
11017                 rsurface.lightmapcolor4f_bufferoffset = 0;
11018         }
11019         else
11020         {
11021                 rsurface.lightmapcolor4f = rsurface.modellightmapcolor4f;
11022                 rsurface.lightmapcolor4f_bufferobject = rsurface.modellightmapcolor4f_bufferobject;
11023                 rsurface.lightmapcolor4f_bufferoffset = rsurface.modellightmapcolor4f_bufferoffset;
11024         }
11025         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
11026         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
11027         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
11028         GL_Color(r, g, b, a);
11029         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11030 }
11031
11032 static void RSurf_DrawBatch_GL11_ApplyVertexShade(int texturenumsurfaces, const msurface_t **texturesurfacelist, float *r, float *g, float *b, float *a, qboolean *applycolor)
11033 {
11034         int texturesurfaceindex;
11035         int i;
11036         float f;
11037         float alpha;
11038         const float *v;
11039         const float *n;
11040         float *c;
11041         vec3_t ambientcolor;
11042         vec3_t diffusecolor;
11043         vec3_t lightdir;
11044         // TODO: optimize
11045         // model lighting
11046         VectorCopy(rsurface.modellight_lightdir, lightdir);
11047         f = 0.5f * r_refdef.lightmapintensity;
11048         ambientcolor[0] = rsurface.modellight_ambient[0] * *r * f;
11049         ambientcolor[1] = rsurface.modellight_ambient[1] * *g * f;
11050         ambientcolor[2] = rsurface.modellight_ambient[2] * *b * f;
11051         diffusecolor[0] = rsurface.modellight_diffuse[0] * *r * f;
11052         diffusecolor[1] = rsurface.modellight_diffuse[1] * *g * f;
11053         diffusecolor[2] = rsurface.modellight_diffuse[2] * *b * f;
11054         alpha = *a;
11055         if (VectorLength2(diffusecolor) > 0 && rsurface.normal3f)
11056         {
11057                 // generate color arrays for the surfaces in this list
11058                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
11059                 {
11060                         const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
11061                         int numverts = surface->num_vertices;
11062                         v = rsurface.vertex3f + 3 * surface->num_firstvertex;
11063                         n = rsurface.normal3f + 3 * surface->num_firstvertex;
11064                         c = rsurface.array_color4f + 4 * surface->num_firstvertex;
11065                         // q3-style directional shading
11066                         for (i = 0;i < numverts;i++, v += 3, n += 3, c += 4)
11067                         {
11068                                 if ((f = DotProduct(n, lightdir)) > 0)
11069                                         VectorMA(ambientcolor, f, diffusecolor, c);
11070                                 else
11071                                         VectorCopy(ambientcolor, c);
11072                                 c[3] = alpha;
11073                         }
11074                 }
11075                 *r = 1;
11076                 *g = 1;
11077                 *b = 1;
11078                 *a = 1;
11079                 rsurface.lightmapcolor4f = rsurface.array_color4f;
11080                 rsurface.lightmapcolor4f_bufferobject = 0;
11081                 rsurface.lightmapcolor4f_bufferoffset = 0;
11082                 *applycolor = false;
11083         }
11084         else
11085         {
11086                 *r = ambientcolor[0];
11087                 *g = ambientcolor[1];
11088                 *b = ambientcolor[2];
11089                 rsurface.lightmapcolor4f = NULL;
11090                 rsurface.lightmapcolor4f_bufferobject = 0;
11091                 rsurface.lightmapcolor4f_bufferoffset = 0;
11092         }
11093 }
11094
11095 static void RSurf_DrawBatch_GL11_VertexShade(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
11096 {
11097         RSurf_DrawBatch_GL11_ApplyVertexShade(texturenumsurfaces, texturesurfacelist, &r, &g, &b, &a, &applycolor);
11098         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
11099         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
11100         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
11101         GL_Color(r, g, b, a);
11102         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11103 }
11104
11105 void RSurf_SetupDepthAndCulling(void)
11106 {
11107         // submodels are biased to avoid z-fighting with world surfaces that they
11108         // may be exactly overlapping (avoids z-fighting artifacts on certain
11109         // doors and things in Quake maps)
11110         GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
11111         GL_PolygonOffset(rsurface.basepolygonfactor + rsurface.texture->biaspolygonfactor, rsurface.basepolygonoffset + rsurface.texture->biaspolygonoffset);
11112         GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
11113         GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_refdef.view.cullface_back);
11114 }
11115
11116 static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, const msurface_t **texturesurfacelist)
11117 {
11118         // transparent sky would be ridiculous
11119         if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
11120                 return;
11121         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
11122         skyrenderlater = true;
11123         RSurf_SetupDepthAndCulling();
11124         GL_DepthMask(true);
11125         // LordHavoc: HalfLife maps have freaky skypolys so don't use
11126         // skymasking on them, and Quake3 never did sky masking (unlike
11127         // software Quake and software Quake2), so disable the sky masking
11128         // in Quake3 maps as it causes problems with q3map2 sky tricks,
11129         // and skymasking also looks very bad when noclipping outside the
11130         // level, so don't use it then either.
11131         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_refdef.viewcache.world_novis)
11132         {
11133                 GL_Color(r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2], 1);
11134                 R_Mesh_ColorPointer(NULL, 0, 0);
11135                 R_Mesh_ResetTextureState();
11136                 if (skyrendermasked)
11137                 {
11138                         R_SetupShader_DepthOrShadow();
11139                         // depth-only (masking)
11140                         GL_ColorMask(0,0,0,0);
11141                         // just to make sure that braindead drivers don't draw
11142                         // anything despite that colormask...
11143                         GL_BlendFunc(GL_ZERO, GL_ONE);
11144                 }
11145                 else
11146                 {
11147                         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
11148                         // fog sky
11149                         GL_BlendFunc(GL_ONE, GL_ZERO);
11150                 }
11151                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
11152                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11153                 if (skyrendermasked)
11154                         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
11155         }
11156         R_Mesh_ResetTextureState();
11157         GL_Color(1, 1, 1, 1);
11158 }
11159
11160 extern rtexture_t *r_shadow_prepasslightingdiffusetexture;
11161 extern rtexture_t *r_shadow_prepasslightingspeculartexture;
11162 static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
11163 {
11164         if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA)))
11165                 return;
11166         RSurf_PrepareVerticesForBatch(true, true, texturenumsurfaces, texturesurfacelist);
11167         if (prepass)
11168         {
11169                 // render screenspace normalmap to texture
11170                 GL_DepthMask(true);
11171                 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_DEFERREDGEOMETRY);
11172                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11173         }
11174         else if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_CAMERA)) && !r_waterstate.renderingscene)
11175         {
11176                 // render water or distortion background, then blend surface on top
11177                 GL_DepthMask(true);
11178                 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BACKGROUND);
11179                 RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist);
11180                 GL_DepthMask(false);
11181                 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE);
11182                 if (rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
11183                         RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist);
11184                 else
11185                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11186         }
11187         else
11188         {
11189                 // render surface normally
11190                 GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED));
11191                 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE);
11192                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
11193                         RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist);
11194                 else if (rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
11195                         RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist);
11196                 else
11197                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11198         }
11199 }
11200
11201 static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
11202 {
11203         // OpenGL 1.3 path - anything not completely ancient
11204         int texturesurfaceindex;
11205         qboolean applycolor;
11206         qboolean applyfog;
11207         int layerindex;
11208         const texturelayer_t *layer;
11209         RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
11210
11211         for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
11212         {
11213                 vec4_t layercolor;
11214                 int layertexrgbscale;
11215                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
11216                 {
11217                         if (layerindex == 0)
11218                                 GL_AlphaTest(true);
11219                         else
11220                         {
11221                                 GL_AlphaTest(false);
11222                                 qglDepthFunc(GL_EQUAL);CHECKGLERROR
11223                         }
11224                 }
11225                 GL_DepthMask(layer->depthmask && writedepth);
11226                 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
11227                 if (layer->color[0] > 2 || layer->color[1] > 2 || layer->color[2] > 2)
11228                 {
11229                         layertexrgbscale = 4;
11230                         VectorScale(layer->color, 0.25f, layercolor);
11231                 }
11232                 else if (layer->color[0] > 1 || layer->color[1] > 1 || layer->color[2] > 1)
11233                 {
11234                         layertexrgbscale = 2;
11235                         VectorScale(layer->color, 0.5f, layercolor);
11236                 }
11237                 else
11238                 {
11239                         layertexrgbscale = 1;
11240                         VectorScale(layer->color, 1.0f, layercolor);
11241                 }
11242                 layercolor[3] = layer->color[3];
11243                 applycolor = layercolor[0] != 1 || layercolor[1] != 1 || layercolor[2] != 1 || layercolor[3] != 1;
11244                 R_Mesh_ColorPointer(NULL, 0, 0);
11245                 applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
11246                 switch (layer->type)
11247                 {
11248                 case TEXTURELAYERTYPE_LITTEXTURE:
11249                         // single-pass lightmapped texture with 2x rgbscale
11250                         R_Mesh_TexBind(0, r_texture_white);
11251                         R_Mesh_TexMatrix(0, NULL);
11252                         R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
11253                         R_Mesh_TexCoordPointer(0, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
11254                         R_Mesh_TexBind(1, layer->texture);
11255                         R_Mesh_TexMatrix(1, &layer->texmatrix);
11256                         R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
11257                         R_Mesh_TexCoordPointer(1, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
11258                         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
11259                                 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
11260                         else if (rsurface.uselightmaptexture)
11261                                 RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
11262                         else
11263                                 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
11264                         break;
11265                 case TEXTURELAYERTYPE_TEXTURE:
11266                         // singletexture unlit texture with transparency support
11267                         R_Mesh_TexBind(0, layer->texture);
11268                         R_Mesh_TexMatrix(0, &layer->texmatrix);
11269                         R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
11270                         R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
11271                         R_Mesh_TexBind(1, 0);
11272                         R_Mesh_TexCoordPointer(1, 2, NULL, 0, 0);
11273                         RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
11274                         break;
11275                 case TEXTURELAYERTYPE_FOG:
11276                         // singletexture fogging
11277                         if (layer->texture)
11278                         {
11279                                 R_Mesh_TexBind(0, layer->texture);
11280                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
11281                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
11282                                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
11283                         }
11284                         else
11285                         {
11286                                 R_Mesh_TexBind(0, 0);
11287                                 R_Mesh_TexCoordPointer(0, 2, NULL, 0, 0);
11288                         }
11289                         R_Mesh_TexBind(1, 0);
11290                         R_Mesh_TexCoordPointer(1, 2, NULL, 0, 0);
11291                         // generate a color array for the fog pass
11292                         R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
11293                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
11294                         {
11295                                 int i;
11296                                 float f;
11297                                 const float *v;
11298                                 float *c;
11299                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
11300                                 for (i = 0, v = (rsurface.vertex3f + 3 * surface->num_firstvertex), c = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4)
11301                                 {
11302                                         f = 1 - RSurf_FogVertex(v);
11303                                         c[0] = layercolor[0];
11304                                         c[1] = layercolor[1];
11305                                         c[2] = layercolor[2];
11306                                         c[3] = f * layercolor[3];
11307                                 }
11308                         }
11309                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11310                         break;
11311                 default:
11312                         Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
11313                 }
11314         }
11315         CHECKGLERROR
11316         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
11317         {
11318                 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
11319                 GL_AlphaTest(false);
11320         }
11321 }
11322
11323 static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
11324 {
11325         // OpenGL 1.1 - crusty old voodoo path
11326         int texturesurfaceindex;
11327         qboolean applyfog;
11328         int layerindex;
11329         const texturelayer_t *layer;
11330         RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
11331
11332         for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
11333         {
11334                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
11335                 {
11336                         if (layerindex == 0)
11337                                 GL_AlphaTest(true);
11338                         else
11339                         {
11340                                 GL_AlphaTest(false);
11341                                 qglDepthFunc(GL_EQUAL);CHECKGLERROR
11342                         }
11343                 }
11344                 GL_DepthMask(layer->depthmask && writedepth);
11345                 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
11346                 R_Mesh_ColorPointer(NULL, 0, 0);
11347                 applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
11348                 switch (layer->type)
11349                 {
11350                 case TEXTURELAYERTYPE_LITTEXTURE:
11351                         if (layer->blendfunc1 == GL_ONE && layer->blendfunc2 == GL_ZERO)
11352                         {
11353                                 // two-pass lit texture with 2x rgbscale
11354                                 // first the lightmap pass
11355                                 R_Mesh_TexBind(0, r_texture_white);
11356                                 R_Mesh_TexMatrix(0, NULL);
11357                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
11358                                 R_Mesh_TexCoordPointer(0, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
11359                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
11360                                         RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
11361                                 else if (rsurface.uselightmaptexture)
11362                                         RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
11363                                 else
11364                                         RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
11365                                 // then apply the texture to it
11366                                 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
11367                                 R_Mesh_TexBind(0, layer->texture);
11368                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
11369                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
11370                                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
11371                                 RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layer->color[0] * 0.5f, layer->color[1] * 0.5f, layer->color[2] * 0.5f, layer->color[3], layer->color[0] != 2 || layer->color[1] != 2 || layer->color[2] != 2 || layer->color[3] != 1, false);
11372                         }
11373                         else
11374                         {
11375                                 // single pass vertex-lighting-only texture with 1x rgbscale and transparency support
11376                                 R_Mesh_TexBind(0, layer->texture);
11377                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
11378                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
11379                                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
11380                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
11381                                         RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
11382                                 else
11383                                         RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
11384                         }
11385                         break;
11386                 case TEXTURELAYERTYPE_TEXTURE:
11387                         // singletexture unlit texture with transparency support
11388                         R_Mesh_TexBind(0, layer->texture);
11389                         R_Mesh_TexMatrix(0, &layer->texmatrix);
11390                         R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
11391                         R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
11392                         RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
11393                         break;
11394                 case TEXTURELAYERTYPE_FOG:
11395                         // singletexture fogging
11396                         if (layer->texture)
11397                         {
11398                                 R_Mesh_TexBind(0, layer->texture);
11399                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
11400                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
11401                                 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
11402                         }
11403                         else
11404                         {
11405                                 R_Mesh_TexBind(0, 0);
11406                                 R_Mesh_TexCoordPointer(0, 2, NULL, 0, 0);
11407                         }
11408                         // generate a color array for the fog pass
11409                         R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
11410                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
11411                         {
11412                                 int i;
11413                                 float f;
11414                                 const float *v;
11415                                 float *c;
11416                                 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
11417                                 for (i = 0, v = (rsurface.vertex3f + 3 * surface->num_firstvertex), c = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4)
11418                                 {
11419                                         f = 1 - RSurf_FogVertex(v);
11420                                         c[0] = layer->color[0];
11421                                         c[1] = layer->color[1];
11422                                         c[2] = layer->color[2];
11423                                         c[3] = f * layer->color[3];
11424                                 }
11425                         }
11426                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11427                         break;
11428                 default:
11429                         Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
11430                 }
11431         }
11432         CHECKGLERROR
11433         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
11434         {
11435                 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
11436                 GL_AlphaTest(false);
11437         }
11438 }
11439
11440 static void R_DrawTextureSurfaceList_ShowSurfaces3(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
11441 {
11442         float c[4];
11443
11444         GL_AlphaTest(false);
11445         R_Mesh_ColorPointer(NULL, 0, 0);
11446         R_Mesh_ResetTextureState();
11447         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
11448
11449         if(rsurface.texture && rsurface.texture->currentskinframe)
11450         {
11451                 memcpy(c, rsurface.texture->currentskinframe->avgcolor, sizeof(c));
11452                 c[3] *= rsurface.texture->currentalpha;
11453         }
11454         else
11455         {
11456                 c[0] = 1;
11457                 c[1] = 0;
11458                 c[2] = 1;
11459                 c[3] = 1;
11460         }
11461
11462         if (rsurface.texture->pantstexture || rsurface.texture->shirttexture)
11463         {
11464                 c[0] = 0.5 * (rsurface.colormap_pantscolor[0] * 0.3 + rsurface.colormap_shirtcolor[0] * 0.7);
11465                 c[1] = 0.5 * (rsurface.colormap_pantscolor[1] * 0.3 + rsurface.colormap_shirtcolor[1] * 0.7);
11466                 c[2] = 0.5 * (rsurface.colormap_pantscolor[2] * 0.3 + rsurface.colormap_shirtcolor[2] * 0.7);
11467         }
11468
11469         // brighten it up (as texture value 127 means "unlit")
11470         c[0] *= 2 * r_refdef.view.colorscale;
11471         c[1] *= 2 * r_refdef.view.colorscale;
11472         c[2] *= 2 * r_refdef.view.colorscale;
11473
11474         if(rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERALPHA)
11475                 c[3] *= r_wateralpha.value;
11476
11477         if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHA && c[3] != 1)
11478         {
11479                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
11480                 GL_DepthMask(false);
11481         }
11482         else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
11483         {
11484                 GL_BlendFunc(GL_ONE, GL_ONE);
11485                 GL_DepthMask(false);
11486         }
11487         else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
11488         {
11489                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // can't do alpha test without texture, so let's blend instead
11490                 GL_DepthMask(false);
11491         }
11492         else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
11493         {
11494                 GL_BlendFunc(rsurface.texture->customblendfunc[0], rsurface.texture->customblendfunc[1]);
11495                 GL_DepthMask(false);
11496         }
11497         else
11498         {
11499                 GL_BlendFunc(GL_ONE, GL_ZERO);
11500                 GL_DepthMask(writedepth);
11501         }
11502
11503         rsurface.lightmapcolor4f = NULL;
11504
11505         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
11506         {
11507                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
11508
11509                 rsurface.lightmapcolor4f = NULL;
11510                 rsurface.lightmapcolor4f_bufferobject = 0;
11511                 rsurface.lightmapcolor4f_bufferoffset = 0;
11512         }
11513         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
11514         {
11515                 qboolean applycolor = true;
11516                 float one = 1.0;
11517
11518                 RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
11519
11520                 r_refdef.lightmapintensity = 1;
11521                 RSurf_DrawBatch_GL11_ApplyVertexShade(texturenumsurfaces, texturesurfacelist, &one, &one, &one, &one, &applycolor);
11522                 r_refdef.lightmapintensity = 0; // we're in showsurfaces, after all
11523         }
11524         else
11525         {
11526                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
11527
11528                 rsurface.lightmapcolor4f = rsurface.modellightmapcolor4f;
11529                 rsurface.lightmapcolor4f_bufferobject = rsurface.modellightmapcolor4f_bufferobject;
11530                 rsurface.lightmapcolor4f_bufferoffset = rsurface.modellightmapcolor4f_bufferoffset;
11531         }
11532
11533         if(!rsurface.lightmapcolor4f)
11534                 RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray(texturenumsurfaces, texturesurfacelist);
11535
11536         RSurf_DrawBatch_GL11_ApplyAmbient(texturenumsurfaces, texturesurfacelist);
11537         RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, c[0], c[1], c[2], c[3]);
11538         if(r_refdef.fogenabled)
11539                 RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors(texturenumsurfaces, texturesurfacelist);
11540
11541         R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
11542         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11543 }
11544
11545 static void R_DrawWorldTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
11546 {
11547         CHECKGLERROR
11548         RSurf_SetupDepthAndCulling();
11549         if (r_showsurfaces.integer == 3 && !prepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY))
11550         {
11551                 R_DrawTextureSurfaceList_ShowSurfaces3(texturenumsurfaces, texturesurfacelist, writedepth);
11552                 return;
11553         }
11554         switch (vid.renderpath)
11555         {
11556         case RENDERPATH_GL20:
11557         case RENDERPATH_CGGL:
11558                 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
11559                 break;
11560         case RENDERPATH_GL13:
11561                 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
11562                 break;
11563         case RENDERPATH_GL11:
11564                 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
11565                 break;
11566         }
11567         CHECKGLERROR
11568 }
11569
11570 static void R_DrawModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
11571 {
11572         CHECKGLERROR
11573         RSurf_SetupDepthAndCulling();
11574         if (r_showsurfaces.integer == 3 && !prepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY))
11575         {
11576                 R_DrawTextureSurfaceList_ShowSurfaces3(texturenumsurfaces, texturesurfacelist, writedepth);
11577                 return;
11578         }
11579         switch (vid.renderpath)
11580         {
11581         case RENDERPATH_GL20:
11582         case RENDERPATH_CGGL:
11583                 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
11584                 break;
11585         case RENDERPATH_GL13:
11586                 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
11587                 break;
11588         case RENDERPATH_GL11:
11589                 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
11590                 break;
11591         }
11592         CHECKGLERROR
11593 }
11594
11595 static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
11596 {
11597         int i, j;
11598         int texturenumsurfaces, endsurface;
11599         texture_t *texture;
11600         const msurface_t *surface;
11601 #define MAXBATCH_TRANSPARENTSURFACES 256
11602         const msurface_t *texturesurfacelist[MAXBATCH_TRANSPARENTSURFACES];
11603
11604         // if the model is static it doesn't matter what value we give for
11605         // wantnormals and wanttangents, so this logic uses only rules applicable
11606         // to a model, knowing that they are meaningless otherwise
11607         if (ent == r_refdef.scene.worldentity)
11608                 RSurf_ActiveWorldEntity();
11609         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
11610                 RSurf_ActiveModelEntity(ent, false, false, false);
11611         else
11612         {
11613                 switch (vid.renderpath)
11614                 {
11615                 case RENDERPATH_GL20:
11616                 case RENDERPATH_CGGL:
11617                         RSurf_ActiveModelEntity(ent, true, true, false);
11618                         break;
11619                 case RENDERPATH_GL13:
11620                 case RENDERPATH_GL11:
11621                         RSurf_ActiveModelEntity(ent, true, false, false);
11622                         break;
11623                 }
11624         }
11625
11626         if (r_transparentdepthmasking.integer)
11627         {
11628                 qboolean setup = false;
11629                 for (i = 0;i < numsurfaces;i = j)
11630                 {
11631                         j = i + 1;
11632                         surface = rsurface.modelsurfaces + surfacelist[i];
11633                         texture = surface->texture;
11634                         rsurface.texture = R_GetCurrentTexture(texture);
11635                         rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
11636                         // scan ahead until we find a different texture
11637                         endsurface = min(i + 1024, numsurfaces);
11638                         texturenumsurfaces = 0;
11639                         texturesurfacelist[texturenumsurfaces++] = surface;
11640                         for (;j < endsurface;j++)
11641                         {
11642                                 surface = rsurface.modelsurfaces + surfacelist[j];
11643                                 if (texture != surface->texture || rsurface.uselightmaptexture != (surface->lightmaptexture != NULL))
11644                                         break;
11645                                 texturesurfacelist[texturenumsurfaces++] = surface;
11646                         }
11647                         if (!(rsurface.texture->currentmaterialflags & MATERIALFLAG_TRANSDEPTH))
11648                                 continue;
11649                         // render the range of surfaces as depth
11650                         if (!setup)
11651                         {
11652                                 setup = true;
11653                                 GL_ColorMask(0,0,0,0);
11654                                 GL_Color(1,1,1,1);
11655                                 GL_DepthTest(true);
11656                                 GL_BlendFunc(GL_ONE, GL_ZERO);
11657                                 GL_DepthMask(true);
11658                                 GL_AlphaTest(false);
11659                                 R_Mesh_ColorPointer(NULL, 0, 0);
11660                                 R_Mesh_ResetTextureState();
11661                                 R_SetupShader_DepthOrShadow();
11662                         }
11663                         RSurf_SetupDepthAndCulling();
11664                         RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
11665                         RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11666                 }
11667                 if (setup)
11668                         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
11669         }
11670
11671         for (i = 0;i < numsurfaces;i = j)
11672         {
11673                 j = i + 1;
11674                 surface = rsurface.modelsurfaces + surfacelist[i];
11675                 texture = surface->texture;
11676                 rsurface.texture = R_GetCurrentTexture(texture);
11677                 rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
11678                 // scan ahead until we find a different texture
11679                 endsurface = min(i + MAXBATCH_TRANSPARENTSURFACES, numsurfaces);
11680                 texturenumsurfaces = 0;
11681                 texturesurfacelist[texturenumsurfaces++] = surface;
11682                 for (;j < endsurface;j++)
11683                 {
11684                         surface = rsurface.modelsurfaces + surfacelist[j];
11685                         if (texture != surface->texture || rsurface.uselightmaptexture != (surface->lightmaptexture != NULL))
11686                                 break;
11687                         texturesurfacelist[texturenumsurfaces++] = surface;
11688                 }
11689                 // render the range of surfaces
11690                 if (ent == r_refdef.scene.worldentity)
11691                         R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false, false);
11692                 else
11693                         R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false, false);
11694         }
11695         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
11696         GL_AlphaTest(false);
11697 }
11698
11699 static void R_ProcessTransparentTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, const entity_render_t *queueentity)
11700 {
11701         // transparent surfaces get pushed off into the transparent queue
11702         int surfacelistindex;
11703         const msurface_t *surface;
11704         vec3_t tempcenter, center;
11705         for (surfacelistindex = 0;surfacelistindex < texturenumsurfaces;surfacelistindex++)
11706         {
11707                 surface = texturesurfacelist[surfacelistindex];
11708                 tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f;
11709                 tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f;
11710                 tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f;
11711                 Matrix4x4_Transform(&rsurface.matrix, tempcenter, center);
11712                 if (queueentity->transparent_offset) // transparent offset
11713                 {
11714                         center[0] += r_refdef.view.forward[0]*queueentity->transparent_offset;
11715                         center[1] += r_refdef.view.forward[1]*queueentity->transparent_offset;
11716                         center[2] += r_refdef.view.forward[2]*queueentity->transparent_offset;
11717                 }
11718                 R_MeshQueue_AddTransparent(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_refdef.view.origin : center, R_DrawSurface_TransparentCallback, queueentity, surface - rsurface.modelsurfaces, rsurface.rtlight);
11719         }
11720 }
11721
11722 static void R_ProcessWorldTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, qboolean prepass)
11723 {
11724         const entity_render_t *queueentity = r_refdef.scene.worldentity;
11725         CHECKGLERROR
11726         if (depthonly)
11727         {
11728                 if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
11729                         return;
11730                 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)))
11731                         return;
11732                 RSurf_SetupDepthAndCulling();
11733                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
11734                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11735         }
11736         else if (prepass)
11737         {
11738                 if (!rsurface.texture->currentnumlayers)
11739                         return;
11740                 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
11741                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
11742                 else
11743                         R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
11744         }
11745         else if (r_showsurfaces.integer && !r_refdef.view.showdebug && !prepass)
11746         {
11747                 RSurf_SetupDepthAndCulling();
11748                 GL_AlphaTest(false);
11749                 R_Mesh_ColorPointer(NULL, 0, 0);
11750                 R_Mesh_ResetTextureState();
11751                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
11752                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
11753                 GL_DepthMask(true);
11754                 GL_BlendFunc(GL_ONE, GL_ZERO);
11755                 GL_Color(0, 0, 0, 1);
11756                 GL_DepthTest(writedepth);
11757                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11758         }
11759         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3 && !prepass)
11760         {
11761                 RSurf_SetupDepthAndCulling();
11762                 GL_AlphaTest(false);
11763                 R_Mesh_ColorPointer(NULL, 0, 0);
11764                 R_Mesh_ResetTextureState();
11765                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
11766                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
11767                 GL_DepthMask(true);
11768                 GL_BlendFunc(GL_ONE, GL_ZERO);
11769                 GL_DepthTest(true);
11770                 RSurf_DrawBatch_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
11771         }
11772         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY)
11773                 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
11774         else if (!rsurface.texture->currentnumlayers)
11775                 return;
11776         else if (((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) || (r_showsurfaces.integer == 3 && (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST))) && queueentity)
11777         {
11778                 // in the deferred case, transparent surfaces were queued during prepass
11779                 if (!r_shadow_usingdeferredprepass)
11780                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
11781         }
11782         else
11783         {
11784                 // the alphatest check is to make sure we write depth for anything we skipped on the depth-only pass earlier
11785                 R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST), prepass);
11786         }
11787         CHECKGLERROR
11788 }
11789
11790 void R_QueueWorldSurfaceList(int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass)
11791 {
11792         int i, j;
11793         texture_t *texture;
11794         // break the surface list down into batches by texture and use of lightmapping
11795         for (i = 0;i < numsurfaces;i = j)
11796         {
11797                 j = i + 1;
11798                 // texture is the base texture pointer, rsurface.texture is the
11799                 // current frame/skin the texture is directing us to use (for example
11800                 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
11801                 // use skin 1 instead)
11802                 texture = surfacelist[i]->texture;
11803                 rsurface.texture = R_GetCurrentTexture(texture);
11804                 rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL && !depthonly && !prepass;
11805                 if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW))
11806                 {
11807                         // if this texture is not the kind we want, skip ahead to the next one
11808                         for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
11809                                 ;
11810                         continue;
11811                 }
11812                 // simply scan ahead until we find a different texture or lightmap state
11813                 for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.uselightmaptexture == (surfacelist[j]->lightmaptexture != NULL);j++)
11814                         ;
11815                 // render the range of surfaces
11816                 R_ProcessWorldTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, prepass);
11817         }
11818 }
11819
11820 static void R_ProcessModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, const entity_render_t *queueentity, qboolean prepass)
11821 {
11822         CHECKGLERROR
11823         if (depthonly)
11824         {
11825                 if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
11826                         return;
11827                 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)))
11828                         return;
11829                 RSurf_SetupDepthAndCulling();
11830                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
11831                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11832         }
11833         else if (prepass)
11834         {
11835                 if (!rsurface.texture->currentnumlayers)
11836                         return;
11837                 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
11838                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
11839                 else
11840                         R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
11841         }
11842         else if (r_showsurfaces.integer && !r_refdef.view.showdebug)
11843         {
11844                 RSurf_SetupDepthAndCulling();
11845                 GL_AlphaTest(false);
11846                 R_Mesh_ColorPointer(NULL, 0, 0);
11847                 R_Mesh_ResetTextureState();
11848                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
11849                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
11850                 GL_DepthMask(true);
11851                 GL_BlendFunc(GL_ONE, GL_ZERO);
11852                 GL_Color(0, 0, 0, 1);
11853                 GL_DepthTest(writedepth);
11854                 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
11855         }
11856         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
11857         {
11858                 RSurf_SetupDepthAndCulling();
11859                 GL_AlphaTest(false);
11860                 R_Mesh_ColorPointer(NULL, 0, 0);
11861                 R_Mesh_ResetTextureState();
11862                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
11863                 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
11864                 GL_DepthMask(true);
11865                 GL_BlendFunc(GL_ONE, GL_ZERO);
11866                 GL_DepthTest(true);
11867                 RSurf_DrawBatch_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
11868         }
11869         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY)
11870                 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
11871         else if (!rsurface.texture->currentnumlayers)
11872                 return;
11873         else if (((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) || (r_showsurfaces.integer == 3 && (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST))) && queueentity)
11874         {
11875                 // in the deferred case, transparent surfaces were queued during prepass
11876                 if (!r_shadow_usingdeferredprepass)
11877                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
11878         }
11879         else
11880         {
11881                 // the alphatest check is to make sure we write depth for anything we skipped on the depth-only pass earlier
11882                 R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST), prepass);
11883         }
11884         CHECKGLERROR
11885 }
11886
11887 void R_QueueModelSurfaceList(entity_render_t *ent, int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass)
11888 {
11889         int i, j;
11890         texture_t *texture;
11891         // break the surface list down into batches by texture and use of lightmapping
11892         for (i = 0;i < numsurfaces;i = j)
11893         {
11894                 j = i + 1;
11895                 // texture is the base texture pointer, rsurface.texture is the
11896                 // current frame/skin the texture is directing us to use (for example
11897                 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
11898                 // use skin 1 instead)
11899                 texture = surfacelist[i]->texture;
11900                 rsurface.texture = R_GetCurrentTexture(texture);
11901                 rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL && !depthonly && !prepass;
11902                 if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW))
11903                 {
11904                         // if this texture is not the kind we want, skip ahead to the next one
11905                         for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
11906                                 ;
11907                         continue;
11908                 }
11909                 // simply scan ahead until we find a different texture or lightmap state
11910                 for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.uselightmaptexture == (surfacelist[j]->lightmaptexture != NULL);j++)
11911                         ;
11912                 // render the range of surfaces
11913                 R_ProcessModelTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, ent, prepass);
11914         }
11915 }
11916
11917 float locboxvertex3f[6*4*3] =
11918 {
11919         1,0,1, 1,0,0, 1,1,0, 1,1,1,
11920         0,1,1, 0,1,0, 0,0,0, 0,0,1,
11921         1,1,1, 1,1,0, 0,1,0, 0,1,1,
11922         0,0,1, 0,0,0, 1,0,0, 1,0,1,
11923         0,0,1, 1,0,1, 1,1,1, 0,1,1,
11924         1,0,0, 0,0,0, 0,1,0, 1,1,0
11925 };
11926
11927 unsigned short locboxelements[6*2*3] =
11928 {
11929          0, 1, 2, 0, 2, 3,
11930          4, 5, 6, 4, 6, 7,
11931          8, 9,10, 8,10,11,
11932         12,13,14, 12,14,15,
11933         16,17,18, 16,18,19,
11934         20,21,22, 20,22,23
11935 };
11936
11937 void R_DrawLoc_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
11938 {
11939         int i, j;
11940         cl_locnode_t *loc = (cl_locnode_t *)ent;
11941         vec3_t mins, size;
11942         float vertex3f[6*4*3];
11943         CHECKGLERROR
11944         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
11945         GL_DepthMask(false);
11946         GL_DepthRange(0, 1);
11947         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
11948         GL_DepthTest(true);
11949         GL_CullFace(GL_NONE);
11950         R_EntityMatrix(&identitymatrix);
11951
11952         R_Mesh_VertexPointer(vertex3f, 0, 0);
11953         R_Mesh_ColorPointer(NULL, 0, 0);
11954         R_Mesh_ResetTextureState();
11955         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
11956
11957         i = surfacelist[0];
11958         GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f) * r_refdef.view.colorscale,
11959                          ((i & 0x0038) >> 3) * (1.0f / 7.0f) * r_refdef.view.colorscale,
11960                          ((i & 0x01C0) >> 6) * (1.0f / 7.0f) * r_refdef.view.colorscale,
11961                         surfacelist[0] < 0 ? 0.5f : 0.125f);
11962
11963         if (VectorCompare(loc->mins, loc->maxs))
11964         {
11965                 VectorSet(size, 2, 2, 2);
11966                 VectorMA(loc->mins, -0.5f, size, mins);
11967         }
11968         else
11969         {
11970                 VectorCopy(loc->mins, mins);
11971                 VectorSubtract(loc->maxs, loc->mins, size);
11972         }
11973
11974         for (i = 0;i < 6*4*3;)
11975                 for (j = 0;j < 3;j++, i++)
11976                         vertex3f[i] = mins[j] + size[j] * locboxvertex3f[i];
11977
11978         R_Mesh_Draw(0, 6*4, 0, 6*2, NULL, locboxelements, 0, 0);
11979 }
11980
11981 void R_DrawLocs(void)
11982 {
11983         int index;
11984         cl_locnode_t *loc, *nearestloc;
11985         vec3_t center;
11986         nearestloc = CL_Locs_FindNearest(cl.movement_origin);
11987         for (loc = cl.locnodes, index = 0;loc;loc = loc->next, index++)
11988         {
11989                 VectorLerp(loc->mins, 0.5f, loc->maxs, center);
11990                 R_MeshQueue_AddTransparent(center, R_DrawLoc_Callback, (entity_render_t *)loc, loc == nearestloc ? -1 : index, NULL);
11991         }
11992 }
11993
11994 void R_DecalSystem_Reset(decalsystem_t *decalsystem)
11995 {
11996         if (decalsystem->decals)
11997                 Mem_Free(decalsystem->decals);
11998         memset(decalsystem, 0, sizeof(*decalsystem));
11999 }
12000
12001 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)
12002 {
12003         tridecal_t *decal;
12004         tridecal_t *decals;
12005         int i;
12006
12007         // expand or initialize the system
12008         if (decalsystem->maxdecals <= decalsystem->numdecals)
12009         {
12010                 decalsystem_t old = *decalsystem;
12011                 qboolean useshortelements;
12012                 decalsystem->maxdecals = max(16, decalsystem->maxdecals * 2);
12013                 useshortelements = decalsystem->maxdecals * 3 <= 65536;
12014                 decalsystem->decals = Mem_Alloc(cls.levelmempool, decalsystem->maxdecals * (sizeof(tridecal_t) + sizeof(float[3][3]) + sizeof(float[3][2]) + sizeof(float[3][4]) + sizeof(int[3]) + (useshortelements ? sizeof(unsigned short[3]) : 0)));
12015                 decalsystem->color4f = (float *)(decalsystem->decals + decalsystem->maxdecals);
12016                 decalsystem->texcoord2f = (float *)(decalsystem->color4f + decalsystem->maxdecals*12);
12017                 decalsystem->vertex3f = (float *)(decalsystem->texcoord2f + decalsystem->maxdecals*6);
12018                 decalsystem->element3i = (int *)(decalsystem->vertex3f + decalsystem->maxdecals*9);
12019                 decalsystem->element3s = (useshortelements ? ((unsigned short *)(decalsystem->element3i + decalsystem->maxdecals*3)) : NULL);
12020                 if (decalsystem->numdecals)
12021                         memcpy(decalsystem->decals, old.decals, decalsystem->numdecals * sizeof(tridecal_t));
12022                 if (old.decals)
12023                         Mem_Free(old.decals);
12024                 for (i = 0;i < decalsystem->maxdecals*3;i++)
12025                         decalsystem->element3i[i] = i;
12026                 if (useshortelements)
12027                         for (i = 0;i < decalsystem->maxdecals*3;i++)
12028                                 decalsystem->element3s[i] = i;
12029         }
12030
12031         // grab a decal and search for another free slot for the next one
12032         decals = decalsystem->decals;
12033         decal = decalsystem->decals + (i = decalsystem->freedecal++);
12034         for (i = decalsystem->freedecal;i < decalsystem->numdecals && decals[i].color4ub[0][3];i++)
12035                 ;
12036         decalsystem->freedecal = i;
12037         if (decalsystem->numdecals <= i)
12038                 decalsystem->numdecals = i + 1;
12039
12040         // initialize the decal
12041         decal->lived = 0;
12042         decal->triangleindex = triangleindex;
12043         decal->surfaceindex = surfaceindex;
12044         decal->decalsequence = decalsequence;
12045         decal->color4ub[0][0] = (unsigned char)(c0[0]*255.0f);
12046         decal->color4ub[0][1] = (unsigned char)(c0[1]*255.0f);
12047         decal->color4ub[0][2] = (unsigned char)(c0[2]*255.0f);
12048         decal->color4ub[0][3] = 255;
12049         decal->color4ub[1][0] = (unsigned char)(c1[0]*255.0f);
12050         decal->color4ub[1][1] = (unsigned char)(c1[1]*255.0f);
12051         decal->color4ub[1][2] = (unsigned char)(c1[2]*255.0f);
12052         decal->color4ub[1][3] = 255;
12053         decal->color4ub[2][0] = (unsigned char)(c2[0]*255.0f);
12054         decal->color4ub[2][1] = (unsigned char)(c2[1]*255.0f);
12055         decal->color4ub[2][2] = (unsigned char)(c2[2]*255.0f);
12056         decal->color4ub[2][3] = 255;
12057         decal->vertex3f[0][0] = v0[0];
12058         decal->vertex3f[0][1] = v0[1];
12059         decal->vertex3f[0][2] = v0[2];
12060         decal->vertex3f[1][0] = v1[0];
12061         decal->vertex3f[1][1] = v1[1];
12062         decal->vertex3f[1][2] = v1[2];
12063         decal->vertex3f[2][0] = v2[0];
12064         decal->vertex3f[2][1] = v2[1];
12065         decal->vertex3f[2][2] = v2[2];
12066         decal->texcoord2f[0][0] = t0[0];
12067         decal->texcoord2f[0][1] = t0[1];
12068         decal->texcoord2f[1][0] = t1[0];
12069         decal->texcoord2f[1][1] = t1[1];
12070         decal->texcoord2f[2][0] = t2[0];
12071         decal->texcoord2f[2][1] = t2[1];
12072 }
12073
12074 extern cvar_t cl_decals_bias;
12075 extern cvar_t cl_decals_models;
12076 extern cvar_t cl_decals_newsystem_intensitymultiplier;
12077 // baseparms, parms, temps
12078 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)
12079 {
12080         int cornerindex;
12081         int index;
12082         float v[9][3];
12083         const float *vertex3f;
12084         int numpoints;
12085         float points[2][9][3];
12086         float temp[3];
12087         float tc[9][2];
12088         float f;
12089         float c[9][4];
12090         const int *e;
12091
12092         e = rsurface.modelelement3i + 3*triangleindex;
12093
12094         vertex3f = rsurface.modelvertex3f;
12095
12096         for (cornerindex = 0;cornerindex < 3;cornerindex++)
12097         {
12098                 index = 3*e[cornerindex];
12099                 VectorCopy(vertex3f + index, v[cornerindex]);
12100         }
12101         // cull backfaces
12102         //TriangleNormal(v[0], v[1], v[2], normal);
12103         //if (DotProduct(normal, localnormal) < 0.0f)
12104         //      continue;
12105         // clip by each of the box planes formed from the projection matrix
12106         // if anything survives, we emit the decal
12107         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]);
12108         if (numpoints < 3)
12109                 return;
12110         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]);
12111         if (numpoints < 3)
12112                 return;
12113         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]);
12114         if (numpoints < 3)
12115                 return;
12116         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]);
12117         if (numpoints < 3)
12118                 return;
12119         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]);
12120         if (numpoints < 3)
12121                 return;
12122         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]);
12123         if (numpoints < 3)
12124                 return;
12125         // some part of the triangle survived, so we have to accept it...
12126         if (dynamic)
12127         {
12128                 // dynamic always uses the original triangle
12129                 numpoints = 3;
12130                 for (cornerindex = 0;cornerindex < 3;cornerindex++)
12131                 {
12132                         index = 3*e[cornerindex];
12133                         VectorCopy(vertex3f + index, v[cornerindex]);
12134                 }
12135         }
12136         for (cornerindex = 0;cornerindex < numpoints;cornerindex++)
12137         {
12138                 // convert vertex positions to texcoords
12139                 Matrix4x4_Transform(projection, v[cornerindex], temp);
12140                 tc[cornerindex][0] = (temp[1]+1.0f)*0.5f * (s2-s1) + s1;
12141                 tc[cornerindex][1] = (temp[2]+1.0f)*0.5f * (t2-t1) + t1;
12142                 // calculate distance fade from the projection origin
12143                 f = a * (1.0f-fabs(temp[0])) * cl_decals_newsystem_intensitymultiplier.value;
12144                 f = bound(0.0f, f, 1.0f);
12145                 c[cornerindex][0] = r * f;
12146                 c[cornerindex][1] = g * f;
12147                 c[cornerindex][2] = b * f;
12148                 c[cornerindex][3] = 1.0f;
12149                 //VectorMA(v[cornerindex], cl_decals_bias.value, localnormal, v[cornerindex]);
12150         }
12151         if (dynamic)
12152                 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);
12153         else
12154                 for (cornerindex = 0;cornerindex < numpoints-2;cornerindex++)
12155                         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);
12156 }
12157 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)
12158 {
12159         matrix4x4_t projection;
12160         decalsystem_t *decalsystem;
12161         qboolean dynamic;
12162         dp_model_t *model;
12163         const msurface_t *surface;
12164         const msurface_t *surfaces;
12165         const int *surfacelist;
12166         const texture_t *texture;
12167         int numtriangles;
12168         int numsurfacelist;
12169         int surfacelistindex;
12170         int surfaceindex;
12171         int triangleindex;
12172         float localorigin[3];
12173         float localnormal[3];
12174         float localmins[3];
12175         float localmaxs[3];
12176         float localsize;
12177         //float normal[3];
12178         float planes[6][4];
12179         float angles[3];
12180         bih_t *bih;
12181         int bih_triangles_count;
12182         int bih_triangles[256];
12183         int bih_surfaces[256];
12184
12185         decalsystem = &ent->decalsystem;
12186         model = ent->model;
12187         if (!model || !ent->allowdecals || ent->alpha < 1 || (ent->flags & (RENDER_ADDITIVE | RENDER_NODEPTHTEST)))
12188         {
12189                 R_DecalSystem_Reset(&ent->decalsystem);
12190                 return;
12191         }
12192
12193         if (!model->brush.data_nodes && !cl_decals_models.integer)
12194         {
12195                 if (decalsystem->model)
12196                         R_DecalSystem_Reset(decalsystem);
12197                 return;
12198         }
12199
12200         if (decalsystem->model != model)
12201                 R_DecalSystem_Reset(decalsystem);
12202         decalsystem->model = model;
12203
12204         RSurf_ActiveModelEntity(ent, false, false, false);
12205
12206         Matrix4x4_Transform(&rsurface.inversematrix, worldorigin, localorigin);
12207         Matrix4x4_Transform3x3(&rsurface.inversematrix, worldnormal, localnormal);
12208         VectorNormalize(localnormal);
12209         localsize = worldsize*rsurface.inversematrixscale;
12210         localmins[0] = localorigin[0] - localsize;
12211         localmins[1] = localorigin[1] - localsize;
12212         localmins[2] = localorigin[2] - localsize;
12213         localmaxs[0] = localorigin[0] + localsize;
12214         localmaxs[1] = localorigin[1] + localsize;
12215         localmaxs[2] = localorigin[2] + localsize;
12216
12217         //VectorCopy(localnormal, planes[4]);
12218         //VectorVectors(planes[4], planes[2], planes[0]);
12219         AnglesFromVectors(angles, localnormal, NULL, false);
12220         AngleVectors(angles, planes[0], planes[2], planes[4]);
12221         VectorNegate(planes[0], planes[1]);
12222         VectorNegate(planes[2], planes[3]);
12223         VectorNegate(planes[4], planes[5]);
12224         planes[0][3] = DotProduct(planes[0], localorigin) - localsize;
12225         planes[1][3] = DotProduct(planes[1], localorigin) - localsize;
12226         planes[2][3] = DotProduct(planes[2], localorigin) - localsize;
12227         planes[3][3] = DotProduct(planes[3], localorigin) - localsize;
12228         planes[4][3] = DotProduct(planes[4], localorigin) - localsize;
12229         planes[5][3] = DotProduct(planes[5], localorigin) - localsize;
12230
12231 #if 1
12232 // works
12233 {
12234         matrix4x4_t forwardprojection;
12235         Matrix4x4_CreateFromQuakeEntity(&forwardprojection, localorigin[0], localorigin[1], localorigin[2], angles[0], angles[1], angles[2], localsize);
12236         Matrix4x4_Invert_Simple(&projection, &forwardprojection);
12237 }
12238 #else
12239 // broken
12240 {
12241         float projectionvector[4][3];
12242         VectorScale(planes[0], ilocalsize, projectionvector[0]);
12243         VectorScale(planes[2], ilocalsize, projectionvector[1]);
12244         VectorScale(planes[4], ilocalsize, projectionvector[2]);
12245         projectionvector[0][0] = planes[0][0] * ilocalsize;
12246         projectionvector[0][1] = planes[1][0] * ilocalsize;
12247         projectionvector[0][2] = planes[2][0] * ilocalsize;
12248         projectionvector[1][0] = planes[0][1] * ilocalsize;
12249         projectionvector[1][1] = planes[1][1] * ilocalsize;
12250         projectionvector[1][2] = planes[2][1] * ilocalsize;
12251         projectionvector[2][0] = planes[0][2] * ilocalsize;
12252         projectionvector[2][1] = planes[1][2] * ilocalsize;
12253         projectionvector[2][2] = planes[2][2] * ilocalsize;
12254         projectionvector[3][0] = -(localorigin[0]*projectionvector[0][0]+localorigin[1]*projectionvector[1][0]+localorigin[2]*projectionvector[2][0]);
12255         projectionvector[3][1] = -(localorigin[0]*projectionvector[0][1]+localorigin[1]*projectionvector[1][1]+localorigin[2]*projectionvector[2][1]);
12256         projectionvector[3][2] = -(localorigin[0]*projectionvector[0][2]+localorigin[1]*projectionvector[1][2]+localorigin[2]*projectionvector[2][2]);
12257         Matrix4x4_FromVectors(&projection, projectionvector[0], projectionvector[1], projectionvector[2], projectionvector[3]);
12258 }
12259 #endif
12260
12261         dynamic = model->surfmesh.isanimated;
12262         numsurfacelist = model->nummodelsurfaces;
12263         surfacelist = model->sortedmodelsurfaces;
12264         surfaces = model->data_surfaces;
12265
12266         bih = NULL;
12267         bih_triangles_count = -1;
12268         if(!dynamic)
12269         {
12270                 if(model->render_bih.numleafs)
12271                         bih = &model->render_bih;
12272                 else if(model->collision_bih.numleafs)
12273                         bih = &model->collision_bih;
12274         }
12275         if(bih)
12276                 bih_triangles_count = BIH_GetTriangleListForBox(bih, sizeof(bih_triangles) / sizeof(*bih_triangles), bih_triangles, bih_surfaces, localmins, localmaxs);
12277         if(bih_triangles_count == 0)
12278                 return;
12279         if(bih_triangles_count > (int) (sizeof(bih_triangles) / sizeof(*bih_triangles))) // hit too many, likely bad anyway
12280                 return;
12281         if(bih_triangles_count > 0)
12282         {
12283                 for (triangleindex = 0; triangleindex < bih_triangles_count; ++triangleindex)
12284                 {
12285                         surfaceindex = bih_surfaces[triangleindex];
12286                         surface = surfaces + surfaceindex;
12287                         texture = surface->texture;
12288                         if (texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SKY | MATERIALFLAG_SHORTDEPTHRANGE | MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
12289                                 continue;
12290                         if (texture->surfaceflags & Q3SURFACEFLAG_NOMARKS)
12291                                 continue;
12292                         R_DecalSystem_SplatTriangle(decalsystem, r, g, b, a, s1, t1, s2, t2, decalsequence, dynamic, planes, &projection, bih_triangles[triangleindex], surfaceindex);
12293                 }
12294         }
12295         else
12296         {
12297                 for (surfacelistindex = 0;surfacelistindex < numsurfacelist;surfacelistindex++)
12298                 {
12299                         surfaceindex = surfacelist[surfacelistindex];
12300                         surface = surfaces + surfaceindex;
12301                         // check cull box first because it rejects more than any other check
12302                         if (!dynamic && !BoxesOverlap(surface->mins, surface->maxs, localmins, localmaxs))
12303                                 continue;
12304                         // skip transparent surfaces
12305                         texture = surface->texture;
12306                         if (texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SKY | MATERIALFLAG_SHORTDEPTHRANGE | MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
12307                                 continue;
12308                         if (texture->surfaceflags & Q3SURFACEFLAG_NOMARKS)
12309                                 continue;
12310                         numtriangles = surface->num_triangles;
12311                         for (triangleindex = 0; triangleindex < numtriangles; triangleindex++)
12312                                 R_DecalSystem_SplatTriangle(decalsystem, r, g, b, a, s1, t1, s2, t2, decalsequence, dynamic, planes, &projection, triangleindex + surface->num_firsttriangle, surfaceindex);
12313                 }
12314         }
12315 }
12316
12317 // do not call this outside of rendering code - use R_DecalSystem_SplatEntities instead
12318 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)
12319 {
12320         int renderentityindex;
12321         float worldmins[3];
12322         float worldmaxs[3];
12323         entity_render_t *ent;
12324
12325         if (!cl_decals_newsystem.integer)
12326                 return;
12327
12328         worldmins[0] = worldorigin[0] - worldsize;
12329         worldmins[1] = worldorigin[1] - worldsize;
12330         worldmins[2] = worldorigin[2] - worldsize;
12331         worldmaxs[0] = worldorigin[0] + worldsize;
12332         worldmaxs[1] = worldorigin[1] + worldsize;
12333         worldmaxs[2] = worldorigin[2] + worldsize;
12334
12335         R_DecalSystem_SplatEntity(r_refdef.scene.worldentity, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence);
12336
12337         for (renderentityindex = 0;renderentityindex < r_refdef.scene.numentities;renderentityindex++)
12338         {
12339                 ent = r_refdef.scene.entities[renderentityindex];
12340                 if (!BoxesOverlap(ent->mins, ent->maxs, worldmins, worldmaxs))
12341                         continue;
12342
12343                 R_DecalSystem_SplatEntity(ent, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence);
12344         }
12345 }
12346
12347 typedef struct r_decalsystem_splatqueue_s
12348 {
12349         vec3_t worldorigin;
12350         vec3_t worldnormal;
12351         float color[4];
12352         float tcrange[4];
12353         float worldsize;
12354         int decalsequence;
12355 }
12356 r_decalsystem_splatqueue_t;
12357
12358 int r_decalsystem_numqueued = 0;
12359 r_decalsystem_splatqueue_t r_decalsystem_queue[MAX_DECALSYSTEM_QUEUE];
12360
12361 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)
12362 {
12363         r_decalsystem_splatqueue_t *queue;
12364
12365         if (!cl_decals_newsystem.integer || r_decalsystem_numqueued == MAX_DECALSYSTEM_QUEUE)
12366                 return;
12367
12368         queue = &r_decalsystem_queue[r_decalsystem_numqueued++];
12369         VectorCopy(worldorigin, queue->worldorigin);
12370         VectorCopy(worldnormal, queue->worldnormal);
12371         Vector4Set(queue->color, r, g, b, a);
12372         Vector4Set(queue->tcrange, s1, t1, s2, t2);
12373         queue->worldsize = worldsize;
12374         queue->decalsequence = cl.decalsequence++;
12375 }
12376
12377 static void R_DecalSystem_ApplySplatEntitiesQueue(void)
12378 {
12379         int i;
12380         r_decalsystem_splatqueue_t *queue;
12381
12382         for (i = 0, queue = r_decalsystem_queue;i < r_decalsystem_numqueued;i++, queue++)
12383                 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);
12384         r_decalsystem_numqueued = 0;
12385 }
12386
12387 extern cvar_t cl_decals_max;
12388 static void R_DrawModelDecals_FadeEntity(entity_render_t *ent)
12389 {
12390         int i;
12391         decalsystem_t *decalsystem = &ent->decalsystem;
12392         int numdecals;
12393         int killsequence;
12394         tridecal_t *decal;
12395         float frametime;
12396         float lifetime;
12397
12398         if (!decalsystem->numdecals)
12399                 return;
12400
12401         if (r_showsurfaces.integer)
12402                 return;
12403
12404         if (ent->model != decalsystem->model || ent->alpha < 1 || (ent->flags & RENDER_ADDITIVE))
12405         {
12406                 R_DecalSystem_Reset(decalsystem);
12407                 return;
12408         }
12409
12410         killsequence = cl.decalsequence - max(1, cl_decals_max.integer);
12411         lifetime = cl_decals_time.value + cl_decals_fadetime.value;
12412
12413         if (decalsystem->lastupdatetime)
12414                 frametime = (cl.time - decalsystem->lastupdatetime);
12415         else
12416                 frametime = 0;
12417         decalsystem->lastupdatetime = cl.time;
12418         decal = decalsystem->decals;
12419         numdecals = decalsystem->numdecals;
12420
12421         for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++)
12422         {
12423                 if (decal->color4ub[0][3])
12424                 {
12425                         decal->lived += frametime;
12426                         if (killsequence - decal->decalsequence > 0 || decal->lived >= lifetime)
12427                         {
12428                                 memset(decal, 0, sizeof(*decal));
12429                                 if (decalsystem->freedecal > i)
12430                                         decalsystem->freedecal = i;
12431                         }
12432                 }
12433         }
12434         decal = decalsystem->decals;
12435         while (numdecals > 0 && !decal[numdecals-1].color4ub[0][3])
12436                 numdecals--;
12437
12438         // collapse the array by shuffling the tail decals into the gaps
12439         for (;;)
12440         {
12441                 while (decalsystem->freedecal < numdecals && decal[decalsystem->freedecal].color4ub[0][3])
12442                         decalsystem->freedecal++;
12443                 if (decalsystem->freedecal == numdecals)
12444                         break;
12445                 decal[decalsystem->freedecal] = decal[--numdecals];
12446         }
12447
12448         decalsystem->numdecals = numdecals;
12449
12450         if (numdecals <= 0)
12451         {
12452                 // if there are no decals left, reset decalsystem
12453                 R_DecalSystem_Reset(decalsystem);
12454         }
12455 }
12456
12457 extern skinframe_t *decalskinframe;
12458 static void R_DrawModelDecals_Entity(entity_render_t *ent)
12459 {
12460         int i;
12461         decalsystem_t *decalsystem = &ent->decalsystem;
12462         int numdecals;
12463         tridecal_t *decal;
12464         float faderate;
12465         float alpha;
12466         float *v3f;
12467         float *c4f;
12468         float *t2f;
12469         const int *e;
12470         const unsigned char *surfacevisible = ent == r_refdef.scene.worldentity ? r_refdef.viewcache.world_surfacevisible : NULL;
12471         int numtris = 0;
12472
12473         numdecals = decalsystem->numdecals;
12474         if (!numdecals)
12475                 return;
12476
12477         if (r_showsurfaces.integer)
12478                 return;
12479
12480         if (ent->model != decalsystem->model || ent->alpha < 1 || (ent->flags & RENDER_ADDITIVE))
12481         {
12482                 R_DecalSystem_Reset(decalsystem);
12483                 return;
12484         }
12485
12486         // if the model is static it doesn't matter what value we give for
12487         // wantnormals and wanttangents, so this logic uses only rules applicable
12488         // to a model, knowing that they are meaningless otherwise
12489         if (ent == r_refdef.scene.worldentity)
12490                 RSurf_ActiveWorldEntity();
12491         else
12492                 RSurf_ActiveModelEntity(ent, false, false, false);
12493
12494         decalsystem->lastupdatetime = cl.time;
12495         decal = decalsystem->decals;
12496
12497         faderate = 1.0f / max(0.001f, cl_decals_fadetime.value);
12498
12499         // update vertex positions for animated models
12500         v3f = decalsystem->vertex3f;
12501         c4f = decalsystem->color4f;
12502         t2f = decalsystem->texcoord2f;
12503         for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++)
12504         {
12505                 if (!decal->color4ub[0][3])
12506                         continue;
12507
12508                 if (surfacevisible && !surfacevisible[decal->surfaceindex])
12509                         continue;
12510
12511                 // update color values for fading decals
12512                 if (decal->lived >= cl_decals_time.value)
12513                 {
12514                         alpha = 1 - faderate * (decal->lived - cl_decals_time.value);
12515                         alpha *= (1.0f/255.0f);
12516                 }
12517                 else
12518                         alpha = 1.0f/255.0f;
12519
12520                 c4f[ 0] = decal->color4ub[0][0] * alpha;
12521                 c4f[ 1] = decal->color4ub[0][1] * alpha;
12522                 c4f[ 2] = decal->color4ub[0][2] * alpha;
12523                 c4f[ 3] = 1;
12524                 c4f[ 4] = decal->color4ub[1][0] * alpha;
12525                 c4f[ 5] = decal->color4ub[1][1] * alpha;
12526                 c4f[ 6] = decal->color4ub[1][2] * alpha;
12527                 c4f[ 7] = 1;
12528                 c4f[ 8] = decal->color4ub[2][0] * alpha;
12529                 c4f[ 9] = decal->color4ub[2][1] * alpha;
12530                 c4f[10] = decal->color4ub[2][2] * alpha;
12531                 c4f[11] = 1;
12532
12533                 t2f[0] = decal->texcoord2f[0][0];
12534                 t2f[1] = decal->texcoord2f[0][1];
12535                 t2f[2] = decal->texcoord2f[1][0];
12536                 t2f[3] = decal->texcoord2f[1][1];
12537                 t2f[4] = decal->texcoord2f[2][0];
12538                 t2f[5] = decal->texcoord2f[2][1];
12539
12540                 // update vertex positions for animated models
12541                 if (decal->triangleindex >= 0 && decal->triangleindex < rsurface.modelnum_triangles)
12542                 {
12543                         e = rsurface.modelelement3i + 3*decal->triangleindex;
12544                         VectorCopy(rsurface.vertex3f + 3*e[0], v3f);
12545                         VectorCopy(rsurface.vertex3f + 3*e[1], v3f + 3);
12546                         VectorCopy(rsurface.vertex3f + 3*e[2], v3f + 6);
12547                 }
12548                 else
12549                 {
12550                         VectorCopy(decal->vertex3f[0], v3f);
12551                         VectorCopy(decal->vertex3f[1], v3f + 3);
12552                         VectorCopy(decal->vertex3f[2], v3f + 6);
12553                 }
12554
12555                 if (r_refdef.fogenabled)
12556                 {
12557                         alpha = RSurf_FogVertex(v3f);
12558                         VectorScale(c4f, alpha, c4f);
12559                         alpha = RSurf_FogVertex(v3f + 3);
12560                         VectorScale(c4f + 4, alpha, c4f + 4);
12561                         alpha = RSurf_FogVertex(v3f + 6);
12562                         VectorScale(c4f + 8, alpha, c4f + 8);
12563                 }
12564
12565                 v3f += 9;
12566                 c4f += 12;
12567                 t2f += 6;
12568                 numtris++;
12569         }
12570
12571         if (numtris > 0)
12572         {
12573                 r_refdef.stats.drawndecals += numtris;
12574
12575                 // now render the decals all at once
12576                 // (this assumes they all use one particle font texture!)
12577                 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);
12578                 R_Mesh_ResetTextureState();
12579                 R_Mesh_VertexPointer(decalsystem->vertex3f, 0, 0);
12580                 R_Mesh_TexCoordPointer(0, 2, decalsystem->texcoord2f, 0, 0);
12581                 R_Mesh_ColorPointer(decalsystem->color4f, 0, 0);
12582                 GL_DepthMask(false);
12583                 GL_DepthRange(0, 1);
12584                 GL_PolygonOffset(rsurface.basepolygonfactor + r_polygonoffset_decals_factor.value, rsurface.basepolygonoffset + r_polygonoffset_decals_offset.value);
12585                 GL_DepthTest(true);
12586                 GL_CullFace(GL_NONE);
12587                 GL_BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
12588                 R_SetupShader_Generic(decalskinframe->base, NULL, GL_MODULATE, 1);
12589                 R_Mesh_Draw(0, numtris * 3, 0, numtris, decalsystem->element3i, decalsystem->element3s, 0, 0);
12590         }
12591 }
12592
12593 static void R_DrawModelDecals(void)
12594 {
12595         int i, numdecals;
12596
12597         // fade faster when there are too many decals
12598         numdecals = r_refdef.scene.worldentity->decalsystem.numdecals;
12599         for (i = 0;i < r_refdef.scene.numentities;i++)
12600                 numdecals += r_refdef.scene.entities[i]->decalsystem.numdecals;
12601
12602         R_DrawModelDecals_FadeEntity(r_refdef.scene.worldentity);
12603         for (i = 0;i < r_refdef.scene.numentities;i++)
12604                 if (r_refdef.scene.entities[i]->decalsystem.numdecals)
12605                         R_DrawModelDecals_FadeEntity(r_refdef.scene.entities[i]);
12606
12607         R_DecalSystem_ApplySplatEntitiesQueue();
12608
12609         numdecals = r_refdef.scene.worldentity->decalsystem.numdecals;
12610         for (i = 0;i < r_refdef.scene.numentities;i++)
12611                 numdecals += r_refdef.scene.entities[i]->decalsystem.numdecals;
12612
12613         r_refdef.stats.totaldecals += numdecals;
12614
12615         if (r_showsurfaces.integer)
12616                 return;
12617
12618         R_DrawModelDecals_Entity(r_refdef.scene.worldentity);
12619
12620         for (i = 0;i < r_refdef.scene.numentities;i++)
12621         {
12622                 if (!r_refdef.viewcache.entityvisible[i])
12623                         continue;
12624                 if (r_refdef.scene.entities[i]->decalsystem.numdecals)
12625                         R_DrawModelDecals_Entity(r_refdef.scene.entities[i]);
12626         }
12627 }
12628
12629 extern cvar_t mod_collision_bih;
12630 void R_DrawDebugModel(void)
12631 {
12632         entity_render_t *ent = rsurface.entity;
12633         int i, j, k, l, flagsmask;
12634         const msurface_t *surface;
12635         dp_model_t *model = ent->model;
12636         vec3_t v;
12637
12638         flagsmask = MATERIALFLAG_SKY | MATERIALFLAG_WALL;
12639
12640         R_Mesh_ColorPointer(NULL, 0, 0);
12641         R_Mesh_ResetTextureState();
12642         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
12643         GL_DepthRange(0, 1);
12644         GL_DepthTest(!r_showdisabledepthtest.integer);
12645         GL_DepthMask(false);
12646         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
12647
12648         if (r_showcollisionbrushes.value > 0 && model->collision_bih.numleafs)
12649         {
12650                 int triangleindex;
12651                 int bihleafindex;
12652                 qboolean cullbox = ent == r_refdef.scene.worldentity;
12653                 const q3mbrush_t *brush;
12654                 const bih_t *bih = &model->collision_bih;
12655                 const bih_leaf_t *bihleaf;
12656                 float vertex3f[3][3];
12657                 GL_PolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);
12658                 cullbox = false;
12659                 for (bihleafindex = 0, bihleaf = bih->leafs;bihleafindex < bih->numleafs;bihleafindex++, bihleaf++)
12660                 {
12661                         if (cullbox && R_CullBox(bihleaf->mins, bihleaf->maxs))
12662                                 continue;
12663                         switch (bihleaf->type)
12664                         {
12665                         case BIH_BRUSH:
12666                                 brush = model->brush.data_brushes + bihleaf->itemindex;
12667                                 if (brush->colbrushf && brush->colbrushf->numtriangles)
12668                                 {
12669                                         R_Mesh_VertexPointer(brush->colbrushf->points->v, 0, 0);
12670                                         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);
12671                                         R_Mesh_Draw(0, brush->colbrushf->numpoints, 0, brush->colbrushf->numtriangles, brush->colbrushf->elements, NULL, 0, 0);
12672                                 }
12673                                 break;
12674                         case BIH_COLLISIONTRIANGLE:
12675                                 triangleindex = bihleaf->itemindex;
12676                                 VectorCopy(model->brush.data_collisionvertex3f + 3*model->brush.data_collisionelement3i[triangleindex*3+0], vertex3f[0]);
12677                                 VectorCopy(model->brush.data_collisionvertex3f + 3*model->brush.data_collisionelement3i[triangleindex*3+1], vertex3f[1]);
12678                                 VectorCopy(model->brush.data_collisionvertex3f + 3*model->brush.data_collisionelement3i[triangleindex*3+2], vertex3f[2]);
12679                                 R_Mesh_VertexPointer(vertex3f[0], 0, 0);
12680                                 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);
12681                                 R_Mesh_Draw(0, 3, 0, 1, polygonelement3i, polygonelement3s, 0, 0);
12682                                 break;
12683                         case BIH_RENDERTRIANGLE:
12684                                 triangleindex = bihleaf->itemindex;
12685                                 VectorCopy(model->surfmesh.data_vertex3f + 3*model->surfmesh.data_element3i[triangleindex*3+0], vertex3f[0]);
12686                                 VectorCopy(model->surfmesh.data_vertex3f + 3*model->surfmesh.data_element3i[triangleindex*3+1], vertex3f[1]);
12687                                 VectorCopy(model->surfmesh.data_vertex3f + 3*model->surfmesh.data_element3i[triangleindex*3+2], vertex3f[2]);
12688                                 R_Mesh_VertexPointer(vertex3f[0], 0, 0);
12689                                 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);
12690                                 R_Mesh_Draw(0, 3, 0, 1, polygonelement3i, polygonelement3s, 0, 0);
12691                                 break;
12692                         }
12693                 }
12694         }
12695
12696         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
12697
12698         if (r_showtris.integer || r_shownormals.integer)
12699         {
12700                 if (r_showdisabledepthtest.integer)
12701                 {
12702                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
12703                         GL_DepthMask(false);
12704                 }
12705                 else
12706                 {
12707                         GL_BlendFunc(GL_ONE, GL_ZERO);
12708                         GL_DepthMask(true);
12709                 }
12710                 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
12711                 {
12712                         if (ent == r_refdef.scene.worldentity && !r_refdef.viewcache.world_surfacevisible[j])
12713                                 continue;
12714                         rsurface.texture = R_GetCurrentTexture(surface->texture);
12715                         if ((rsurface.texture->currentmaterialflags & flagsmask) && surface->num_triangles)
12716                         {
12717                                 RSurf_PrepareVerticesForBatch(true, true, 1, &surface);
12718                                 if (r_showtris.value > 0)
12719                                 {
12720                                         if (!rsurface.texture->currentlayers->depthmask)
12721                                                 GL_Color(r_refdef.view.colorscale, 0, 0, r_showtris.value);
12722                                         else if (ent == r_refdef.scene.worldentity)
12723                                                 GL_Color(r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale, r_showtris.value);
12724                                         else
12725                                                 GL_Color(0, r_refdef.view.colorscale, 0, r_showtris.value);
12726                                         R_Mesh_VertexPointer(rsurface.vertex3f, 0, 0);
12727                                         R_Mesh_ColorPointer(NULL, 0, 0);
12728                                         R_Mesh_TexCoordPointer(0, 0, NULL, 0, 0);
12729                                         qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
12730                                         //R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, model->surfmesh.data_element3i, NULL, 0, 0);
12731                                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
12732                                         qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
12733                                         CHECKGLERROR
12734                                 }
12735                                 if (r_shownormals.value < 0)
12736                                 {
12737                                         qglBegin(GL_LINES);
12738                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
12739                                         {
12740                                                 VectorCopy(rsurface.vertex3f + l * 3, v);
12741                                                 GL_Color(r_refdef.view.colorscale, 0, 0, 1);
12742                                                 qglVertex3f(v[0], v[1], v[2]);
12743                                                 VectorMA(v, -r_shownormals.value, rsurface.svector3f + l * 3, v);
12744                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
12745                                                 qglVertex3f(v[0], v[1], v[2]);
12746                                         }
12747                                         qglEnd();
12748                                         CHECKGLERROR
12749                                 }
12750                                 if (r_shownormals.value > 0)
12751                                 {
12752                                         qglBegin(GL_LINES);
12753                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
12754                                         {
12755                                                 VectorCopy(rsurface.vertex3f + l * 3, v);
12756                                                 GL_Color(r_refdef.view.colorscale, 0, 0, 1);
12757                                                 qglVertex3f(v[0], v[1], v[2]);
12758                                                 VectorMA(v, r_shownormals.value, rsurface.svector3f + l * 3, v);
12759                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
12760                                                 qglVertex3f(v[0], v[1], v[2]);
12761                                         }
12762                                         qglEnd();
12763                                         CHECKGLERROR
12764                                         qglBegin(GL_LINES);
12765                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
12766                                         {
12767                                                 VectorCopy(rsurface.vertex3f + l * 3, v);
12768                                                 GL_Color(0, r_refdef.view.colorscale, 0, 1);
12769                                                 qglVertex3f(v[0], v[1], v[2]);
12770                                                 VectorMA(v, r_shownormals.value, rsurface.tvector3f + l * 3, v);
12771                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
12772                                                 qglVertex3f(v[0], v[1], v[2]);
12773                                         }
12774                                         qglEnd();
12775                                         CHECKGLERROR
12776                                         qglBegin(GL_LINES);
12777                                         for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
12778                                         {
12779                                                 VectorCopy(rsurface.vertex3f + l * 3, v);
12780                                                 GL_Color(0, 0, r_refdef.view.colorscale, 1);
12781                                                 qglVertex3f(v[0], v[1], v[2]);
12782                                                 VectorMA(v, r_shownormals.value, rsurface.normal3f + l * 3, v);
12783                                                 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
12784                                                 qglVertex3f(v[0], v[1], v[2]);
12785                                         }
12786                                         qglEnd();
12787                                         CHECKGLERROR
12788                                 }
12789                         }
12790                 }
12791                 rsurface.texture = NULL;
12792         }
12793 }
12794
12795 extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
12796 int r_maxsurfacelist = 0;
12797 const msurface_t **r_surfacelist = NULL;
12798 void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass)
12799 {
12800         int i, j, endj, flagsmask;
12801         dp_model_t *model = r_refdef.scene.worldmodel;
12802         msurface_t *surfaces;
12803         unsigned char *update;
12804         int numsurfacelist = 0;
12805         if (model == NULL)
12806                 return;
12807
12808         if (r_maxsurfacelist < model->num_surfaces)
12809         {
12810                 r_maxsurfacelist = model->num_surfaces;
12811                 if (r_surfacelist)
12812                         Mem_Free((msurface_t**)r_surfacelist);
12813                 r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist));
12814         }
12815
12816         RSurf_ActiveWorldEntity();
12817
12818         surfaces = model->data_surfaces;
12819         update = model->brushq1.lightmapupdateflags;
12820
12821         // update light styles on this submodel
12822         if (!skysurfaces && !depthonly && !prepass && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
12823         {
12824                 model_brush_lightstyleinfo_t *style;
12825                 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
12826                 {
12827                         if (style->value != r_refdef.scene.lightstylevalue[style->style])
12828                         {
12829                                 int *list = style->surfacelist;
12830                                 style->value = r_refdef.scene.lightstylevalue[style->style];
12831                                 for (j = 0;j < style->numsurfaces;j++)
12832                                         update[list[j]] = true;
12833                         }
12834                 }
12835         }
12836
12837         flagsmask = skysurfaces ? MATERIALFLAG_SKY : MATERIALFLAG_WALL;
12838
12839         if (debug)
12840         {
12841                 R_DrawDebugModel();
12842                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
12843                 return;
12844         }
12845
12846         rsurface.uselightmaptexture = false;
12847         rsurface.texture = NULL;
12848         rsurface.rtlight = NULL;
12849         numsurfacelist = 0;
12850         // add visible surfaces to draw list
12851         for (i = 0;i < model->nummodelsurfaces;i++)
12852         {
12853                 j = model->sortedmodelsurfaces[i];
12854                 if (r_refdef.viewcache.world_surfacevisible[j])
12855                         r_surfacelist[numsurfacelist++] = surfaces + j;
12856         }
12857         // update lightmaps if needed
12858         if (model->brushq1.firstrender)
12859         {
12860                 model->brushq1.firstrender = false;
12861                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
12862                         if (update[j])
12863                                 R_BuildLightMap(r_refdef.scene.worldentity, surfaces + j);
12864         }
12865         else if (update)
12866         {
12867                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
12868                         if (r_refdef.viewcache.world_surfacevisible[j])
12869                                 if (update[j])
12870                                         R_BuildLightMap(r_refdef.scene.worldentity, surfaces + j);
12871         }
12872         // don't do anything if there were no surfaces
12873         if (!numsurfacelist)
12874         {
12875                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
12876                 return;
12877         }
12878         R_QueueWorldSurfaceList(numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
12879         GL_AlphaTest(false);
12880
12881         // add to stats if desired
12882         if (r_speeds.integer && !skysurfaces && !depthonly)
12883         {
12884                 r_refdef.stats.world_surfaces += numsurfacelist;
12885                 for (j = 0;j < numsurfacelist;j++)
12886                         r_refdef.stats.world_triangles += r_surfacelist[j]->num_triangles;
12887         }
12888
12889         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
12890 }
12891
12892 void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass)
12893 {
12894         int i, j, endj, flagsmask;
12895         dp_model_t *model = ent->model;
12896         msurface_t *surfaces;
12897         unsigned char *update;
12898         int numsurfacelist = 0;
12899         if (model == NULL)
12900                 return;
12901
12902         if (r_maxsurfacelist < model->num_surfaces)
12903         {
12904                 r_maxsurfacelist = model->num_surfaces;
12905                 if (r_surfacelist)
12906                         Mem_Free((msurface_t **)r_surfacelist);
12907                 r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist));
12908         }
12909
12910         // if the model is static it doesn't matter what value we give for
12911         // wantnormals and wanttangents, so this logic uses only rules applicable
12912         // to a model, knowing that they are meaningless otherwise
12913         if (ent == r_refdef.scene.worldentity)
12914                 RSurf_ActiveWorldEntity();
12915         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
12916                 RSurf_ActiveModelEntity(ent, false, false, false);
12917         else if (prepass)
12918                 RSurf_ActiveModelEntity(ent, true, true, true);
12919         else if (depthonly)
12920         {
12921                 switch (vid.renderpath)
12922                 {
12923                 case RENDERPATH_GL20:
12924                 case RENDERPATH_CGGL:
12925                         RSurf_ActiveModelEntity(ent, model->wantnormals, model->wanttangents, false);
12926                         break;
12927                 case RENDERPATH_GL13:
12928                 case RENDERPATH_GL11:
12929                         RSurf_ActiveModelEntity(ent, model->wantnormals, false, false);
12930                         break;
12931                 }
12932         }
12933         else
12934         {
12935                 switch (vid.renderpath)
12936                 {
12937                 case RENDERPATH_GL20:
12938                 case RENDERPATH_CGGL:
12939                         RSurf_ActiveModelEntity(ent, true, true, false);
12940                         break;
12941                 case RENDERPATH_GL13:
12942                 case RENDERPATH_GL11:
12943                         RSurf_ActiveModelEntity(ent, true, false, false);
12944                         break;
12945                 }
12946         }
12947
12948         surfaces = model->data_surfaces;
12949         update = model->brushq1.lightmapupdateflags;
12950
12951         // update light styles
12952         if (!skysurfaces && !depthonly && !prepass && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
12953         {
12954                 model_brush_lightstyleinfo_t *style;
12955                 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
12956                 {
12957                         if (style->value != r_refdef.scene.lightstylevalue[style->style])
12958                         {
12959                                 int *list = style->surfacelist;
12960                                 style->value = r_refdef.scene.lightstylevalue[style->style];
12961                                 for (j = 0;j < style->numsurfaces;j++)
12962                                         update[list[j]] = true;
12963                         }
12964                 }
12965         }
12966
12967         flagsmask = skysurfaces ? MATERIALFLAG_SKY : MATERIALFLAG_WALL;
12968
12969         if (debug)
12970         {
12971                 R_DrawDebugModel();
12972                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
12973                 return;
12974         }
12975
12976         rsurface.uselightmaptexture = false;
12977         rsurface.texture = NULL;
12978         rsurface.rtlight = NULL;
12979         numsurfacelist = 0;
12980         // add visible surfaces to draw list
12981         for (i = 0;i < model->nummodelsurfaces;i++)
12982                 r_surfacelist[numsurfacelist++] = surfaces + model->sortedmodelsurfaces[i];
12983         // don't do anything if there were no surfaces
12984         if (!numsurfacelist)
12985         {
12986                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
12987                 return;
12988         }
12989         // update lightmaps if needed
12990         if (update)
12991         {
12992                 int updated = 0;
12993                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
12994                 {
12995                         if (update[j])
12996                         {
12997                                 updated++;
12998                                 R_BuildLightMap(ent, surfaces + j);
12999                         }
13000                 }
13001         }
13002         if (update)
13003                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
13004                         if (update[j])
13005                                 R_BuildLightMap(ent, surfaces + j);
13006         R_QueueModelSurfaceList(ent, numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
13007         GL_AlphaTest(false);
13008
13009         // add to stats if desired
13010         if (r_speeds.integer && !skysurfaces && !depthonly)
13011         {
13012                 r_refdef.stats.entities_surfaces += numsurfacelist;
13013                 for (j = 0;j < numsurfacelist;j++)
13014                         r_refdef.stats.entities_triangles += r_surfacelist[j]->num_triangles;
13015         }
13016
13017         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
13018 }
13019
13020 void R_DrawCustomSurface(skinframe_t *skinframe, const matrix4x4_t *texmatrix, int materialflags, int firstvertex, int numvertices, int firsttriangle, int numtriangles, qboolean writedepth, qboolean prepass)
13021 {
13022         static texture_t texture;
13023         static msurface_t surface;
13024         const msurface_t *surfacelist = &surface;
13025
13026         // fake enough texture and surface state to render this geometry
13027
13028         texture.update_lastrenderframe = -1; // regenerate this texture
13029         texture.basematerialflags = materialflags | MATERIALFLAG_CUSTOMSURFACE | MATERIALFLAG_WALL;
13030         texture.currentskinframe = skinframe;
13031         texture.currenttexmatrix = *texmatrix; // requires MATERIALFLAG_CUSTOMSURFACE
13032         texture.offsetmapping = OFFSETMAPPING_OFF;
13033         texture.offsetscale = 1;
13034         texture.specularscalemod = 1;
13035         texture.specularpowermod = 1;
13036
13037         surface.texture = &texture;
13038         surface.num_triangles = numtriangles;
13039         surface.num_firsttriangle = firsttriangle;
13040         surface.num_vertices = numvertices;
13041         surface.num_firstvertex = firstvertex;
13042
13043         // now render it
13044         rsurface.texture = R_GetCurrentTexture(surface.texture);
13045         rsurface.uselightmaptexture = false;
13046         R_DrawModelTextureSurfaceList(1, &surfacelist, writedepth, prepass);
13047 }
13048
13049 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)
13050 {
13051         static msurface_t surface;
13052         const msurface_t *surfacelist = &surface;
13053
13054         // fake enough texture and surface state to render this geometry
13055
13056         surface.texture = texture;
13057         surface.num_triangles = numtriangles;
13058         surface.num_firsttriangle = firsttriangle;
13059         surface.num_vertices = numvertices;
13060         surface.num_firstvertex = firstvertex;
13061
13062         // now render it
13063         rsurface.texture = R_GetCurrentTexture(surface.texture);
13064         rsurface.uselightmaptexture = false;
13065         R_DrawModelTextureSurfaceList(1, &surfacelist, writedepth, prepass);
13066 }