gl_rmain.c

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 See the GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 */
  20 // r_main.c
  21
  22 #include "quakedef.h"
  23 #include "cl_dyntexture.h"
  24 #include "r_shadow.h"
  25 #include "polygon.h"
  26 #include "image.h"
  27 #include "ft2.h"
  28 #include "csprogs.h"
  29 #include "cl_video.h"
  30
  31 #ifdef SUPPORTD3D
  32 #include <d3d9.h>
  33 extern LPDIRECT3DDEVICE9 vid_d3d9dev;
  34 #endif
  35
  36 mempool_t *r_main_mempool;
  37 rtexturepool_t *r_main_texturepool;
  38
  39 static int r_textureframe = 0; ///< used only by R_GetCurrentTexture
  40
  41 static qboolean r_loadnormalmap;
  42 static qboolean r_loadgloss;
  43 qboolean r_loadfog;
  44 static qboolean r_loaddds;
  45 static qboolean r_savedds;
  46
  47 //
  48 // screen size info
  49 //
  50 r_refdef_t r_refdef;
  51
  52 cvar_t r_motionblur = {CVAR_SAVE, "r_motionblur", "0", "motionblur value scale - 0.5 recommended"};
  53 cvar_t r_damageblur = {CVAR_SAVE, "r_damageblur", "0", "motionblur based on damage"};
  54 cvar_t r_motionblur_vmin = {CVAR_SAVE, "r_motionblur_vmin", "300", "minimum influence from velocity"};
  55 cvar_t r_motionblur_vmax = {CVAR_SAVE, "r_motionblur_vmax", "600", "maximum influence from velocity"};
  56 cvar_t r_motionblur_bmin = {CVAR_SAVE, "r_motionblur_bmin", "0.5", "velocity at which there is no blur yet (may be negative to always have some blur)"};
  57 cvar_t r_motionblur_vcoeff = {CVAR_SAVE, "r_motionblur_vcoeff", "0.05", "sliding average reaction time for velocity"};
  58 cvar_t r_motionblur_maxblur = {CVAR_SAVE, "r_motionblur_maxblur", "0.88", "cap for motionblur alpha value"};
  59 cvar_t r_motionblur_randomize = {CVAR_SAVE, "r_motionblur_randomize", "0.1", "randomizing coefficient to workaround ghosting"};
  60
  61 // TODO do we want a r_equalize_entities cvar that works on all ents, or would that be a cheat?
  62 cvar_t r_equalize_entities_fullbright = {CVAR_SAVE, "r_equalize_entities_fullbright", "0", "render fullbright entities by equalizing their lightness, not by not rendering light"};
  63 cvar_t r_equalize_entities_minambient = {CVAR_SAVE, "r_equalize_entities_minambient", "0.5", "light equalizing: ensure at least this ambient/diffuse ratio"};
  64 cvar_t r_equalize_entities_by = {CVAR_SAVE, "r_equalize_entities_by", "0.7", "light equalizing: exponent of dynamics compression (0 = no compression, 1 = full compression)"};
  65 cvar_t r_equalize_entities_to = {CVAR_SAVE, "r_equalize_entities_to", "0.8", "light equalizing: target light level"};
  66
  67 cvar_t r_depthfirst = {CVAR_SAVE, "r_depthfirst", "0", "renders a depth-only version of the scene before normal rendering begins to eliminate overdraw, values: 0 = off, 1 = world depth, 2 = world and model depth"};
  68 cvar_t r_useinfinitefarclip = {CVAR_SAVE, "r_useinfinitefarclip", "1", "enables use of a special kind of projection matrix that has an extremely large farclip"};
  69 cvar_t r_farclip_base = {0, "r_farclip_base", "65536", "farclip (furthest visible distance) for rendering when r_useinfinitefarclip is 0"};
  70 cvar_t r_farclip_world = {0, "r_farclip_world", "2", "adds map size to farclip multiplied by this value"};
  71 cvar_t r_nearclip = {0, "r_nearclip", "1", "distance from camera of nearclip plane" };
  72 cvar_t r_showbboxes = {0, "r_showbboxes", "0", "shows bounding boxes of server entities, value controls opacity scaling (1 = 10%,  10 = 100%)"};
  73 cvar_t r_showsurfaces = {0, "r_showsurfaces", "0", "1 shows surfaces as different colors, or a value of 2 shows triangle draw order (for analyzing whether meshes are optimized for vertex cache)"};
  74 cvar_t r_showtris = {0, "r_showtris", "0", "shows triangle outlines, value controls brightness (can be above 1)"};
  75 cvar_t r_shownormals = {0, "r_shownormals", "0", "shows per-vertex surface normals and tangent vectors for bumpmapped lighting"};
  76 cvar_t r_showlighting = {0, "r_showlighting", "0", "shows areas lit by lights, useful for finding out why some areas of a map render slowly (bright orange = lots of passes = slow), a value of 2 disables depth testing which can be interesting but not very useful"};
  77 cvar_t r_showshadowvolumes = {0, "r_showshadowvolumes", "0", "shows areas shadowed by lights, useful for finding out why some areas of a map render slowly (bright blue = lots of passes = slow), a value of 2 disables depth testing which can be interesting but not very useful"};
  78 cvar_t r_showcollisionbrushes = {0, "r_showcollisionbrushes", "0", "draws collision brushes in quake3 maps (mode 1), mode 2 disables rendering of world (trippy!)"};
  79 cvar_t r_showcollisionbrushes_polygonfactor = {0, "r_showcollisionbrushes_polygonfactor", "-1", "expands outward the brush polygons a little bit, used to make collision brushes appear infront of walls"};
  80 cvar_t r_showcollisionbrushes_polygonoffset = {0, "r_showcollisionbrushes_polygonoffset", "0", "nudges brush polygon depth in hardware depth units, used to make collision brushes appear infront of walls"};
  81 cvar_t r_showdisabledepthtest = {0, "r_showdisabledepthtest", "0", "disables depth testing on r_show* cvars, allowing you to see what hidden geometry the graphics card is processing"};
  82 cvar_t r_drawportals = {0, "r_drawportals", "0", "shows portals (separating polygons) in world interior in quake1 maps"};
  83 cvar_t r_drawentities = {0, "r_drawentities","1", "draw entities (doors, players, projectiles, etc)"};
  84 cvar_t r_draw2d = {0, "r_draw2d","1", "draw 2D stuff (dangerous to turn off)"};
  85 cvar_t r_drawworld = {0, "r_drawworld","1", "draw world (most static stuff)"};
  86 cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1", "draw your weapon model"};
  87 cvar_t r_drawexteriormodel = {0, "r_drawexteriormodel","1", "draw your player model (e.g. in chase cam, reflections)"};
  88 cvar_t r_cullentities_trace = {0, "r_cullentities_trace", "1", "probabistically cull invisible entities"};
  89 cvar_t r_cullentities_trace_samples = {0, "r_cullentities_trace_samples", "2", "number of samples to test for entity culling (in addition to center sample)"};
  90 cvar_t r_cullentities_trace_tempentitysamples = {0, "r_cullentities_trace_tempentitysamples", "-1", "number of samples to test for entity culling of temp entities (including all CSQC entities), -1 disables trace culling on these entities to prevent flicker (pvs still applies)"};
  91 cvar_t r_cullentities_trace_enlarge = {0, "r_cullentities_trace_enlarge", "0", "box enlargement for entity culling"};
  92 cvar_t r_cullentities_trace_delay = {0, "r_cullentities_trace_delay", "1", "number of seconds until the entity gets actually culled"};
  93 cvar_t r_speeds = {0, "r_speeds","0", "displays rendering statistics and per-subsystem timings"};
  94 cvar_t r_fullbright = {0, "r_fullbright","0", "makes map very bright and renders faster"};
  95
  96 cvar_t r_fakelight = {0, "r_fakelight","0", "render 'fake' lighting instead of real lightmaps"};
  97 cvar_t r_fakelight_intensity = {0, "r_fakelight_intensity","0.75", "fakelight intensity modifier"};
  98 #define FAKELIGHT_ENABLED (r_fakelight.integer >= 2 || (r_fakelight.integer && r_refdef.scene.worldmodel && !r_refdef.scene.worldmodel->lit))
  99
 100 cvar_t r_wateralpha = {CVAR_SAVE, "r_wateralpha","1", "opacity of water polygons"};
 101 cvar_t r_dynamic = {CVAR_SAVE, "r_dynamic","1", "enables dynamic lights (rocket glow and such)"};
 102 cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1", "enables glowing pixels in quake textures (changes need r_restart to take effect)"};
 103 cvar_t r_shadows = {CVAR_SAVE, "r_shadows", "0", "casts fake stencil shadows from models onto the world (rtlights are unaffected by this); when set to 2, always cast the shadows in the direction set by r_shadows_throwdirection, otherwise use the model lighting."};
 104 cvar_t r_shadows_darken = {CVAR_SAVE, "r_shadows_darken", "0.5", "how much shadowed areas will be darkened"};
 105 cvar_t r_shadows_throwdistance = {CVAR_SAVE, "r_shadows_throwdistance", "500", "how far to cast shadows from models"};
 106 cvar_t r_shadows_throwdirection = {CVAR_SAVE, "r_shadows_throwdirection", "0 0 -1", "override throwing direction for r_shadows 2"};
 107 cvar_t r_shadows_drawafterrtlighting = {CVAR_SAVE, "r_shadows_drawafterrtlighting", "0", "draw fake shadows AFTER realtime lightning is drawn. May be useful for simulating fast sunlight on large outdoor maps with only one noshadow rtlight. The price is less realistic appearance of dynamic light shadows."};
 108 cvar_t r_shadows_castfrombmodels = {CVAR_SAVE, "r_shadows_castfrombmodels", "0", "do cast shadows from bmodels"};
 109 cvar_t r_shadows_focus = {CVAR_SAVE, "r_shadows_focus", "0 0 0", "offset the shadowed area focus"};
 110 cvar_t r_shadows_shadowmapscale = {CVAR_SAVE, "r_shadows_shadowmapscale", "1", "increases shadowmap quality (multiply global shadowmap precision) for fake shadows. Needs shadowmapping ON."};
 111 cvar_t r_q1bsp_skymasking = {0, "r_q1bsp_skymasking", "1", "allows sky polygons in quake1 maps to obscure other geometry"};
 112 cvar_t r_polygonoffset_submodel_factor = {0, "r_polygonoffset_submodel_factor", "0", "biases depth values of world submodels such as doors, to prevent z-fighting artifacts in Quake maps"};
 113 cvar_t r_polygonoffset_submodel_offset = {0, "r_polygonoffset_submodel_offset", "14", "biases depth values of world submodels such as doors, to prevent z-fighting artifacts in Quake maps"};
 114 cvar_t r_polygonoffset_decals_factor = {0, "r_polygonoffset_decals_factor", "0", "biases depth values of decals to prevent z-fighting artifacts"};
 115 cvar_t r_polygonoffset_decals_offset = {0, "r_polygonoffset_decals_offset", "-14", "biases depth values of decals to prevent z-fighting artifacts"};
 116 cvar_t r_fog_exp2 = {0, "r_fog_exp2", "0", "uses GL_EXP2 fog (as in Nehahra) rather than realistic GL_EXP fog"};
 117 cvar_t r_drawfog = {CVAR_SAVE, "r_drawfog", "1", "allows one to disable fog rendering"};
 118 cvar_t r_transparentdepthmasking = {CVAR_SAVE, "r_transparentdepthmasking", "0", "enables depth writes on transparent meshes whose materially is normally opaque, this prevents seeing the inside of a transparent mesh"};
 119
 120 cvar_t gl_fogenable = {0, "gl_fogenable", "0", "nehahra fog enable (for Nehahra compatibility only)"};
 121 cvar_t gl_fogdensity = {0, "gl_fogdensity", "0.25", "nehahra fog density (recommend values below 0.1) (for Nehahra compatibility only)"};
 122 cvar_t gl_fogred = {0, "gl_fogred","0.3", "nehahra fog color red value (for Nehahra compatibility only)"};
 123 cvar_t gl_foggreen = {0, "gl_foggreen","0.3", "nehahra fog color green value (for Nehahra compatibility only)"};
 124 cvar_t gl_fogblue = {0, "gl_fogblue","0.3", "nehahra fog color blue value (for Nehahra compatibility only)"};
 125 cvar_t gl_fogstart = {0, "gl_fogstart", "0", "nehahra fog start distance (for Nehahra compatibility only)"};
 126 cvar_t gl_fogend = {0, "gl_fogend","0", "nehahra fog end distance (for Nehahra compatibility only)"};
 127 cvar_t gl_skyclip = {0, "gl_skyclip", "4608", "nehahra farclip distance - the real fog end (for Nehahra compatibility only)"};
 128
 129 cvar_t r_texture_dds_load = {CVAR_SAVE, "r_texture_dds_load", "0", "load compressed dds/filename.dds texture instead of filename.tga, if the file exists (requires driver support)"};
 130 cvar_t r_texture_dds_save = {CVAR_SAVE, "r_texture_dds_save", "0", "save compressed dds/filename.dds texture when filename.tga is loaded, so that it can be loaded instead next time"};
 131
 132 cvar_t r_texture_convertsRGB_2d = {0, "r_texture_convertsRGB_2d", "0", "load textures as sRGB and convert to linear for proper shading"};
 133 cvar_t r_texture_convertsRGB_skin = {0, "r_texture_convertsRGB_skin", "0", "load textures as sRGB and convert to linear for proper shading"};
 134 cvar_t r_texture_convertsRGB_cubemap = {0, "r_texture_convertsRGB_cubemap", "0", "load textures as sRGB and convert to linear for proper shading"};
 135 cvar_t r_texture_convertsRGB_skybox = {0, "r_texture_convertsRGB_skybox", "0", "load textures as sRGB and convert to linear for proper shading"};
 136 cvar_t r_texture_convertsRGB_particles = {0, "r_texture_convertsRGB_particles", "0", "load textures as sRGB and convert to linear for proper shading"};
 137
 138 cvar_t r_textureunits = {0, "r_textureunits", "32", "number of texture units to use in GL 1.1 and GL 1.3 rendering paths"};
 139 static cvar_t gl_combine = {CVAR_READONLY, "gl_combine", "1", "indicates whether the OpenGL 1.3 rendering path is active"};
 140 static cvar_t r_glsl = {CVAR_READONLY, "r_glsl", "1", "indicates whether the OpenGL 2.0 rendering path is active"};
 141
 142 cvar_t r_glsl_deluxemapping = {CVAR_SAVE, "r_glsl_deluxemapping", "1", "use per pixel lighting on deluxemap-compiled q3bsp maps (or a value of 2 forces deluxemap shading even without deluxemaps)"};
 143 cvar_t r_glsl_offsetmapping = {CVAR_SAVE, "r_glsl_offsetmapping", "0", "offset mapping effect (also known as parallax mapping or virtual displacement mapping)"};
 144 cvar_t r_glsl_offsetmapping_reliefmapping = {CVAR_SAVE, "r_glsl_offsetmapping_reliefmapping", "0", "relief mapping effect (higher quality)"};
 145 cvar_t r_glsl_offsetmapping_scale = {CVAR_SAVE, "r_glsl_offsetmapping_scale", "0.04", "how deep the offset mapping effect is"};
 146 cvar_t r_glsl_postprocess = {CVAR_SAVE, "r_glsl_postprocess", "0", "use a GLSL postprocessing shader"};
 147 cvar_t r_glsl_postprocess_uservec1 = {CVAR_SAVE, "r_glsl_postprocess_uservec1", "0 0 0 0", "a 4-component vector to pass as uservec1 to the postprocessing shader (only useful if default.glsl has been customized)"};
 148 cvar_t r_glsl_postprocess_uservec2 = {CVAR_SAVE, "r_glsl_postprocess_uservec2", "0 0 0 0", "a 4-component vector to pass as uservec2 to the postprocessing shader (only useful if default.glsl has been customized)"};
 149 cvar_t r_glsl_postprocess_uservec3 = {CVAR_SAVE, "r_glsl_postprocess_uservec3", "0 0 0 0", "a 4-component vector to pass as uservec3 to the postprocessing shader (only useful if default.glsl has been customized)"};
 150 cvar_t r_glsl_postprocess_uservec4 = {CVAR_SAVE, "r_glsl_postprocess_uservec4", "0 0 0 0", "a 4-component vector to pass as uservec4 to the postprocessing shader (only useful if default.glsl has been customized)"};
 151 cvar_t r_glsl_postprocess_uservec1_enable = {CVAR_SAVE, "r_glsl_postprocess_uservec1_enable", "1", "enables postprocessing uservec1 usage, creates USERVEC1 define (only useful if default.glsl has been customized)"};
 152 cvar_t r_glsl_postprocess_uservec2_enable = {CVAR_SAVE, "r_glsl_postprocess_uservec2_enable", "1", "enables postprocessing uservec2 usage, creates USERVEC1 define (only useful if default.glsl has been customized)"};
 153 cvar_t r_glsl_postprocess_uservec3_enable = {CVAR_SAVE, "r_glsl_postprocess_uservec3_enable", "1", "enables postprocessing uservec3 usage, creates USERVEC1 define (only useful if default.glsl has been customized)"};
 154 cvar_t r_glsl_postprocess_uservec4_enable = {CVAR_SAVE, "r_glsl_postprocess_uservec4_enable", "1", "enables postprocessing uservec4 usage, creates USERVEC1 define (only useful if default.glsl has been customized)"};
 155
 156 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)"};
 157 cvar_t r_water_clippingplanebias = {CVAR_SAVE, "r_water_clippingplanebias", "1", "a rather technical setting which avoids black pixels around water edges"};
 158 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"};
 159 cvar_t r_water_refractdistort = {CVAR_SAVE, "r_water_refractdistort", "0.01", "how much water refractions shimmer"};
 160 cvar_t r_water_reflectdistort = {CVAR_SAVE, "r_water_reflectdistort", "0.01", "how much water reflections shimmer"};
 161 cvar_t r_water_scissormode = {0, "r_water_scissormode", "3", "scissor (1) or cull (2) or both (3) water renders"};
 162
 163 cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "0", "enables animation smoothing on sprites"};
 164 cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1", "enables animation smoothing on models"};
 165 cvar_t r_lerplightstyles = {CVAR_SAVE, "r_lerplightstyles", "0", "enable animation smoothing on flickering lights"};
 166 cvar_t r_waterscroll = {CVAR_SAVE, "r_waterscroll", "1", "makes water scroll around, value controls how much"};
 167
 168 cvar_t r_bloom = {CVAR_SAVE, "r_bloom", "0", "enables bloom effect (makes bright pixels affect neighboring pixels)"};
 169 cvar_t r_bloom_colorscale = {CVAR_SAVE, "r_bloom_colorscale", "1", "how bright the glow is"};
 170 cvar_t r_bloom_brighten = {CVAR_SAVE, "r_bloom_brighten", "2", "how bright the glow is, after subtract/power"};
 171 cvar_t r_bloom_blur = {CVAR_SAVE, "r_bloom_blur", "4", "how large the glow is"};
 172 cvar_t r_bloom_resolution = {CVAR_SAVE, "r_bloom_resolution", "320", "what resolution to perform the bloom effect at (independent of screen resolution)"};
 173 cvar_t r_bloom_colorexponent = {CVAR_SAVE, "r_bloom_colorexponent", "1", "how exagerated the glow is"};
 174 cvar_t r_bloom_colorsubtract = {CVAR_SAVE, "r_bloom_colorsubtract", "0.125", "reduces bloom colors by a certain amount"};
 175
 176 cvar_t r_hdr = {CVAR_SAVE, "r_hdr", "0", "enables High Dynamic Range bloom effect (higher quality version of r_bloom)"};
 177 cvar_t r_hdr_scenebrightness = {CVAR_SAVE, "r_hdr_scenebrightness", "1", "global rendering brightness"};
 178 cvar_t r_hdr_glowintensity = {CVAR_SAVE, "r_hdr_glowintensity", "1", "how bright light emitting textures should appear"};
 179 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)"};
 180
 181 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"};
 182
 183 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"};
 184
 185 cvar_t gl_lightmaps = {0, "gl_lightmaps", "0", "draws only lightmaps, no texture (for level designers)"};
 186
 187 cvar_t r_test = {0, "r_test", "0", "internal development use only, leave it alone (usually does nothing anyway)"};
 188 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"};
 189 cvar_t r_track_sprites_flags = {CVAR_SAVE, "r_track_sprites_flags", "1", "1: Rotate sprites accodringly, 2: Make it a continuous rotation"};
 190 cvar_t r_track_sprites_scalew = {CVAR_SAVE, "r_track_sprites_scalew", "1", "width scaling of tracked sprites"};
 191 cvar_t r_track_sprites_scaleh = {CVAR_SAVE, "r_track_sprites_scaleh", "1", "height scaling of tracked sprites"};
 192 cvar_t r_overheadsprites_perspective = {CVAR_SAVE, "r_overheadsprites_perspective", "5", "fake perspective effect for SPR_OVERHEAD sprites"};
 193 cvar_t r_overheadsprites_pushback = {CVAR_SAVE, "r_overheadsprites_pushback", "15", "how far to pull the SPR_OVERHEAD sprites toward the eye (used to avoid intersections with 3D models)"};
 194 cvar_t r_overheadsprites_scalex = {CVAR_SAVE, "r_overheadsprites_scalex", "1", "additional scale for overhead sprites for x axis"};
 195 cvar_t r_overheadsprites_scaley = {CVAR_SAVE, "r_overheadsprites_scaley", "1", "additional scale for overhead sprites for y axis"};
 196
 197 cvar_t r_glsl_saturation = {CVAR_SAVE, "r_glsl_saturation", "1", "saturation multiplier (only working in glsl!)"};
 198 cvar_t r_glsl_saturation_redcompensate = {CVAR_SAVE, "r_glsl_saturation_redcompensate", "0", "a 'vampire sight' addition to desaturation effect, does compensation for red color, r_glsl_restart is required"};
 199
 200 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)"};
 201
 202 extern cvar_t v_glslgamma;
 203
 204 extern qboolean v_flipped_state;
 205
 206 static struct r_bloomstate_s
 207 {
 208         qboolean enabled;
 209         qboolean hdr;
 210
 211         int bloomwidth, bloomheight;
 212
 213         int screentexturewidth, screentextureheight;
 214         rtexture_t *texture_screen; /// \note also used for motion blur if enabled!
 215
 216         int bloomtexturewidth, bloomtextureheight;
 217         rtexture_t *texture_bloom;
 218
 219         // arrays for rendering the screen passes
 220         float screentexcoord2f[8];
 221         float bloomtexcoord2f[8];
 222         float offsettexcoord2f[8];
 223
 224         r_viewport_t viewport;
 225 }
 226 r_bloomstate;
 227
 228 r_waterstate_t r_waterstate;
 229
 230 /// shadow volume bsp struct with automatically growing nodes buffer
 231 svbsp_t r_svbsp;
 232
 233 rtexture_t *r_texture_blanknormalmap;
 234 rtexture_t *r_texture_white;
 235 rtexture_t *r_texture_grey128;
 236 rtexture_t *r_texture_black;
 237 rtexture_t *r_texture_notexture;
 238 rtexture_t *r_texture_whitecube;
 239 rtexture_t *r_texture_normalizationcube;
 240 rtexture_t *r_texture_fogattenuation;
 241 rtexture_t *r_texture_fogheighttexture;
 242 rtexture_t *r_texture_gammaramps;
 243 unsigned int r_texture_gammaramps_serial;
 244 //rtexture_t *r_texture_fogintensity;
 245 rtexture_t *r_texture_reflectcube;
 246
 247 // TODO: hash lookups?
 248 typedef struct cubemapinfo_s
 249 {
 250         char basename[64];
 251         rtexture_t *texture;
 252 }
 253 cubemapinfo_t;
 254
 255 int r_texture_numcubemaps;
 256 cubemapinfo_t r_texture_cubemaps[MAX_CUBEMAPS];
 257
 258 unsigned int r_queries[MAX_OCCLUSION_QUERIES];
 259 unsigned int r_numqueries;
 260 unsigned int r_maxqueries;
 261
 262 typedef struct r_qwskincache_s
 263 {
 264         char name[MAX_QPATH];
 265         skinframe_t *skinframe;
 266 }
 267 r_qwskincache_t;
 268
 269 static r_qwskincache_t *r_qwskincache;
 270 static int r_qwskincache_size;
 271
 272 /// vertex coordinates for a quad that covers the screen exactly
 273 extern const float r_screenvertex3f[12];
 274 extern const float r_d3dscreenvertex3f[12];
 275 const float r_screenvertex3f[12] =
 276 {
 277         0, 0, 0,
 278         1, 0, 0,
 279         1, 1, 0,
 280         0, 1, 0
 281 };
 282 const float r_d3dscreenvertex3f[12] =
 283 {
 284         0, 1, 0,
 285         1, 1, 0,
 286         1, 0, 0,
 287         0, 0, 0
 288 };
 289
 290 void R_ModulateColors(float *in, float *out, int verts, float r, float g, float b)
 291 {
 292         int i;
 293         for (i = 0;i < verts;i++)
 294         {
 295                 out[0] = in[0] * r;
 296                 out[1] = in[1] * g;
 297                 out[2] = in[2] * b;
 298                 out[3] = in[3];
 299                 in += 4;
 300                 out += 4;
 301         }
 302 }
 303
 304 void R_FillColors(float *out, int verts, float r, float g, float b, float a)
 305 {
 306         int i;
 307         for (i = 0;i < verts;i++)
 308         {
 309                 out[0] = r;
 310                 out[1] = g;
 311                 out[2] = b;
 312                 out[3] = a;
 313                 out += 4;
 314         }
 315 }
 316
 317 // FIXME: move this to client?
 318 void FOG_clear(void)
 319 {
 320         if (gamemode == GAME_NEHAHRA)
 321         {
 322                 Cvar_Set("gl_fogenable", "0");
 323                 Cvar_Set("gl_fogdensity", "0.2");
 324                 Cvar_Set("gl_fogred", "0.3");
 325                 Cvar_Set("gl_foggreen", "0.3");
 326                 Cvar_Set("gl_fogblue", "0.3");
 327         }
 328         r_refdef.fog_density = 0;
 329         r_refdef.fog_red = 0;
 330         r_refdef.fog_green = 0;
 331         r_refdef.fog_blue = 0;
 332         r_refdef.fog_alpha = 1;
 333         r_refdef.fog_start = 0;
 334         r_refdef.fog_end = 16384;
 335         r_refdef.fog_height = 1<<30;
 336         r_refdef.fog_fadedepth = 128;
 337         memset(r_refdef.fog_height_texturename, 0, sizeof(r_refdef.fog_height_texturename));
 338 }
 339
 340 static void R_BuildBlankTextures(void)
 341 {
 342         unsigned char data[4];
 343         data[2] = 128; // normal X
 344         data[1] = 128; // normal Y
 345         data[0] = 255; // normal Z
 346         data[3] = 128; // height
 347         r_texture_blanknormalmap = R_LoadTexture2D(r_main_texturepool, "blankbump", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, -1, NULL);
 348         data[0] = 255;
 349         data[1] = 255;
 350         data[2] = 255;
 351         data[3] = 255;
 352         r_texture_white = R_LoadTexture2D(r_main_texturepool, "blankwhite", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, -1, NULL);
 353         data[0] = 128;
 354         data[1] = 128;
 355         data[2] = 128;
 356         data[3] = 255;
 357         r_texture_grey128 = R_LoadTexture2D(r_main_texturepool, "blankgrey128", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, -1, NULL);
 358         data[0] = 0;
 359         data[1] = 0;
 360         data[2] = 0;
 361         data[3] = 255;
 362         r_texture_black = R_LoadTexture2D(r_main_texturepool, "blankblack", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, -1, NULL);
 363 }
 364
 365 static void R_BuildNoTexture(void)
 366 {
 367         int x, y;
 368         unsigned char pix[16][16][4];
 369         // this makes a light grey/dark grey checkerboard texture
 370         for (y = 0;y < 16;y++)
 371         {
 372                 for (x = 0;x < 16;x++)
 373                 {
 374                         if ((y < 8) ^ (x < 8))
 375                         {
 376                                 pix[y][x][0] = 128;
 377                                 pix[y][x][1] = 128;
 378                                 pix[y][x][2] = 128;
 379                                 pix[y][x][3] = 255;
 380                         }
 381                         else
 382                         {
 383                                 pix[y][x][0] = 64;
 384                                 pix[y][x][1] = 64;
 385                                 pix[y][x][2] = 64;
 386                                 pix[y][x][3] = 255;
 387                         }
 388                 }
 389         }
 390         r_texture_notexture = R_LoadTexture2D(r_main_texturepool, "notexture", 16, 16, &pix[0][0][0], TEXTYPE_BGRA, TEXF_MIPMAP | TEXF_PERSISTENT, -1, NULL);
 391 }
 392
 393 static void R_BuildWhiteCube(void)
 394 {
 395         unsigned char data[6*1*1*4];
 396         memset(data, 255, sizeof(data));
 397         r_texture_whitecube = R_LoadTextureCubeMap(r_main_texturepool, "whitecube", 1, data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL);
 398 }
 399
 400 static void R_BuildNormalizationCube(void)
 401 {
 402         int x, y, side;
 403         vec3_t v;
 404         vec_t s, t, intensity;
 405 #define NORMSIZE 64
 406         unsigned char *data;
 407         data = (unsigned char *)Mem_Alloc(tempmempool, 6*NORMSIZE*NORMSIZE*4);
 408         for (side = 0;side < 6;side++)
 409         {
 410                 for (y = 0;y < NORMSIZE;y++)
 411                 {
 412                         for (x = 0;x < NORMSIZE;x++)
 413                         {
 414                                 s = (x + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
 415                                 t = (y + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
 416                                 switch(side)
 417                                 {
 418                                 default:
 419                                 case 0:
 420                                         v[0] = 1;
 421                                         v[1] = -t;
 422                                         v[2] = -s;
 423                                         break;
 424                                 case 1:
 425                                         v[0] = -1;
 426                                         v[1] = -t;
 427                                         v[2] = s;
 428                                         break;
 429                                 case 2:
 430                                         v[0] = s;
 431                                         v[1] = 1;
 432                                         v[2] = t;
 433                                         break;
 434                                 case 3:
 435                                         v[0] = s;
 436                                         v[1] = -1;
 437                                         v[2] = -t;
 438                                         break;
 439                                 case 4:
 440                                         v[0] = s;
 441                                         v[1] = -t;
 442                                         v[2] = 1;
 443                                         break;
 444                                 case 5:
 445                                         v[0] = -s;
 446                                         v[1] = -t;
 447                                         v[2] = -1;
 448                                         break;
 449                                 }
 450                                 intensity = 127.0f / sqrt(DotProduct(v, v));
 451                                 data[((side*64+y)*64+x)*4+2] = (unsigned char)(128.0f + intensity * v[0]);
 452                                 data[((side*64+y)*64+x)*4+1] = (unsigned char)(128.0f + intensity * v[1]);
 453                                 data[((side*64+y)*64+x)*4+0] = (unsigned char)(128.0f + intensity * v[2]);
 454                                 data[((side*64+y)*64+x)*4+3] = 255;
 455                         }
 456                 }
 457         }
 458         r_texture_normalizationcube = R_LoadTextureCubeMap(r_main_texturepool, "normalcube", NORMSIZE, data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL);
 459         Mem_Free(data);
 460 }
 461
 462 static void R_BuildFogTexture(void)
 463 {
 464         int x, b;
 465 #define FOGWIDTH 256
 466         unsigned char data1[FOGWIDTH][4];
 467         //unsigned char data2[FOGWIDTH][4];
 468         double d, r, alpha;
 469
 470         r_refdef.fogmasktable_start = r_refdef.fog_start;
 471         r_refdef.fogmasktable_alpha = r_refdef.fog_alpha;
 472         r_refdef.fogmasktable_range = r_refdef.fogrange;
 473         r_refdef.fogmasktable_density = r_refdef.fog_density;
 474
 475         r = r_refdef.fogmasktable_range / FOGMASKTABLEWIDTH;
 476         for (x = 0;x < FOGMASKTABLEWIDTH;x++)
 477         {
 478                 d = (x * r - r_refdef.fogmasktable_start);
 479                 if(developer_extra.integer)
 480                         Con_DPrintf("%f ", d);
 481                 d = max(0, d);
 482                 if (r_fog_exp2.integer)
 483                         alpha = exp(-r_refdef.fogmasktable_density * r_refdef.fogmasktable_density * 0.0001 * d * d);
 484                 else
 485                         alpha = exp(-r_refdef.fogmasktable_density * 0.004 * d);
 486                 if(developer_extra.integer)
 487                         Con_DPrintf(" : %f ", alpha);
 488                 alpha = 1 - (1 - alpha) * r_refdef.fogmasktable_alpha;
 489                 if(developer_extra.integer)
 490                         Con_DPrintf(" = %f\n", alpha);
 491                 r_refdef.fogmasktable[x] = bound(0, alpha, 1);
 492         }
 493
 494         for (x = 0;x < FOGWIDTH;x++)
 495         {
 496                 b = (int)(r_refdef.fogmasktable[x * (FOGMASKTABLEWIDTH - 1) / (FOGWIDTH - 1)] * 255);
 497                 data1[x][0] = b;
 498                 data1[x][1] = b;
 499                 data1[x][2] = b;
 500                 data1[x][3] = 255;
 501                 //data2[x][0] = 255 - b;
 502                 //data2[x][1] = 255 - b;
 503                 //data2[x][2] = 255 - b;
 504                 //data2[x][3] = 255;
 505         }
 506         if (r_texture_fogattenuation)
 507         {
 508                 R_UpdateTexture(r_texture_fogattenuation, &data1[0][0], 0, 0, FOGWIDTH, 1);
 509                 //R_UpdateTexture(r_texture_fogattenuation, &data2[0][0], 0, 0, FOGWIDTH, 1);
 510         }
 511         else
 512         {
 513                 r_texture_fogattenuation = R_LoadTexture2D(r_main_texturepool, "fogattenuation", FOGWIDTH, 1, &data1[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL);
 514                 //r_texture_fogintensity = R_LoadTexture2D(r_main_texturepool, "fogintensity", FOGWIDTH, 1, &data2[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP, NULL);
 515         }
 516 }
 517
 518 static void R_BuildFogHeightTexture(void)
 519 {
 520         unsigned char *inpixels;
 521         int size;
 522         int x;
 523         int y;
 524         int j;
 525         float c[4];
 526         float f;
 527         inpixels = NULL;
 528         strlcpy(r_refdef.fogheighttexturename, r_refdef.fog_height_texturename, sizeof(r_refdef.fogheighttexturename));
 529         if (r_refdef.fogheighttexturename[0])
 530                 inpixels = loadimagepixelsbgra(r_refdef.fogheighttexturename, true, false, false, NULL);
 531         if (!inpixels)
 532         {
 533                 r_refdef.fog_height_tablesize = 0;
 534                 if (r_texture_fogheighttexture)
 535                         R_FreeTexture(r_texture_fogheighttexture);
 536                 r_texture_fogheighttexture = NULL;
 537                 if (r_refdef.fog_height_table2d)
 538                         Mem_Free(r_refdef.fog_height_table2d);
 539                 r_refdef.fog_height_table2d = NULL;
 540                 if (r_refdef.fog_height_table1d)
 541                         Mem_Free(r_refdef.fog_height_table1d);
 542                 r_refdef.fog_height_table1d = NULL;
 543                 return;
 544         }
 545         size = image_width;
 546         r_refdef.fog_height_tablesize = size;
 547         r_refdef.fog_height_table1d = (unsigned char *)Mem_Alloc(r_main_mempool, size * 4);
 548         r_refdef.fog_height_table2d = (unsigned char *)Mem_Alloc(r_main_mempool, size * size * 4);
 549         memcpy(r_refdef.fog_height_table1d, inpixels, size * 4);
 550         Mem_Free(inpixels);
 551         // LordHavoc: now the magic - what is that table2d for?  it is a cooked
 552         // average fog color table accounting for every fog layer between a point
 553         // and the camera.  (Note: attenuation is handled separately!)
 554         for (y = 0;y < size;y++)
 555         {
 556                 for (x = 0;x < size;x++)
 557                 {
 558                         Vector4Clear(c);
 559                         f = 0;
 560                         if (x < y)
 561                         {
 562                                 for (j = x;j <= y;j++)
 563                                 {
 564                                         Vector4Add(c, r_refdef.fog_height_table1d + j*4, c);
 565                                         f++;
 566                                 }
 567                         }
 568                         else
 569                         {
 570                                 for (j = x;j >= y;j--)
 571                                 {
 572                                         Vector4Add(c, r_refdef.fog_height_table1d + j*4, c);
 573                                         f++;
 574                                 }
 575                         }
 576                         f = 1.0f / f;
 577                         r_refdef.fog_height_table2d[(y*size+x)*4+0] = (unsigned char)(c[0] * f);
 578                         r_refdef.fog_height_table2d[(y*size+x)*4+1] = (unsigned char)(c[1] * f);
 579                         r_refdef.fog_height_table2d[(y*size+x)*4+2] = (unsigned char)(c[2] * f);
 580                         r_refdef.fog_height_table2d[(y*size+x)*4+3] = (unsigned char)(c[3] * f);
 581                 }
 582         }
 583         r_texture_fogheighttexture = R_LoadTexture2D(r_main_texturepool, "fogheighttable", size, size, r_refdef.fog_height_table2d, TEXTYPE_BGRA, TEXF_ALPHA | TEXF_CLAMP, -1, NULL);
 584 }
 585
 586 //=======================================================================================================================================================
 587
 588 static const char *builtinshaderstring =
 589 "// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
 590 "// written by Forest 'LordHavoc' Hale\n"
 591 "// shadowmapping enhancements by Lee 'eihrul' Salzman\n"
 592 "\n"
 593 "#if defined(USEFOGINSIDE) || defined(USEFOGOUTSIDE) || defined(USEFOGHEIGHTTEXTURE)\n"
 594 "# define USEFOG\n"
 595 "#endif\n"
 596 "#if defined(MODE_LIGHTMAP) || defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
 597 "#define USELIGHTMAP\n"
 598 "#endif\n"
 599 "#if defined(USESPECULAR) || defined(USEOFFSETMAPPING) || defined(USEREFLECTCUBE) || defined(MODE_FAKELIGHT)\n"
 600 "#define USEEYEVECTOR\n"
 601 "#endif\n"
 602 "\n"
 603 "#ifdef USESHADOWMAP2D\n"
 604 "# ifdef GL_EXT_gpu_shader4\n"
 605 "#   extension GL_EXT_gpu_shader4 : enable\n"
 606 "# endif\n"
 607 "# ifdef GL_ARB_texture_gather\n"
 608 "#   extension GL_ARB_texture_gather : enable\n"
 609 "# else\n"
 610 "#   ifdef GL_AMD_texture_texture4\n"
 611 "#     extension GL_AMD_texture_texture4 : enable\n"
 612 "#   endif\n"
 613 "# endif\n"
 614 "#endif\n"
 615 "\n"
 616 "//#ifdef USESHADOWSAMPLER\n"
 617 "//# extension GL_ARB_shadow : enable\n"
 618 "//#endif\n"
 619 "\n"
 620 "//#ifdef __GLSL_CG_DATA_TYPES\n"
 621 "//# define myhalf half\n"
 622 "//# define myhalf2 half2\n"
 623 "//# define myhalf3 half3\n"
 624 "//# define myhalf4 half4\n"
 625 "//#else\n"
 626 "# define myhalf float\n"
 627 "# define myhalf2 vec2\n"
 628 "# define myhalf3 vec3\n"
 629 "# define myhalf4 vec4\n"
 630 "//#endif\n"
 631 "\n"
 632 "#ifdef VERTEX_SHADER\n"
 633 "uniform mat4 ModelViewProjectionMatrix;\n"
 634 "#endif\n"
 635 "\n"
 636 "#ifdef MODE_DEPTH_OR_SHADOW\n"
 637 "#ifdef VERTEX_SHADER\n"
 638 "void main(void)\n"
 639 "{\n"
 640 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 641 "}\n"
 642 "#endif\n"
 643 "#else // !MODE_DEPTH_ORSHADOW\n"
 644 "\n"
 645 "\n"
 646 "\n"
 647 "\n"
 648 "#ifdef MODE_SHOWDEPTH\n"
 649 "#ifdef VERTEX_SHADER\n"
 650 "void main(void)\n"
 651 "{\n"
 652 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 653 "       gl_FrontColor = vec4(gl_Position.z, gl_Position.z, gl_Position.z, 1.0);\n"
 654 "}\n"
 655 "#endif\n"
 656 "\n"
 657 "#ifdef FRAGMENT_SHADER\n"
 658 "void main(void)\n"
 659 "{\n"
 660 "       gl_FragColor = gl_Color;\n"
 661 "}\n"
 662 "#endif\n"
 663 "#else // !MODE_SHOWDEPTH\n"
 664 "\n"
 665 "\n"
 666 "\n"
 667 "\n"
 668 "#ifdef MODE_POSTPROCESS\n"
 669 "varying vec2 TexCoord1;\n"
 670 "varying vec2 TexCoord2;\n"
 671 "\n"
 672 "#ifdef VERTEX_SHADER\n"
 673 "void main(void)\n"
 674 "{\n"
 675 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 676 "       TexCoord1 = gl_MultiTexCoord0.xy;\n"
 677 "#ifdef USEBLOOM\n"
 678 "       TexCoord2 = gl_MultiTexCoord4.xy;\n"
 679 "#endif\n"
 680 "}\n"
 681 "#endif\n"
 682 "\n"
 683 "#ifdef FRAGMENT_SHADER\n"
 684 "uniform sampler2D Texture_First;\n"
 685 "#ifdef USEBLOOM\n"
 686 "uniform sampler2D Texture_Second;\n"
 687 "uniform vec4 BloomColorSubtract;\n"
 688 "#endif\n"
 689 "#ifdef USEGAMMARAMPS\n"
 690 "uniform sampler2D Texture_GammaRamps;\n"
 691 "#endif\n"
 692 "#ifdef USESATURATION\n"
 693 "uniform float Saturation;\n"
 694 "#endif\n"
 695 "#ifdef USEVIEWTINT\n"
 696 "uniform vec4 ViewTintColor;\n"
 697 "#endif\n"
 698 "//uncomment these if you want to use them:\n"
 699 "uniform vec4 UserVec1;\n"
 700 "uniform vec4 UserVec2;\n"
 701 "// uniform vec4 UserVec3;\n"
 702 "// uniform vec4 UserVec4;\n"
 703 "// uniform float ClientTime;\n"
 704 "uniform vec2 PixelSize;\n"
 705 "void main(void)\n"
 706 "{\n"
 707 "       gl_FragColor = texture2D(Texture_First, TexCoord1);\n"
 708 "#ifdef USEBLOOM\n"
 709 "       gl_FragColor += max(vec4(0,0,0,0), texture2D(Texture_Second, TexCoord2) - BloomColorSubtract);\n"
 710 "#endif\n"
 711 "#ifdef USEVIEWTINT\n"
 712 "       gl_FragColor = mix(gl_FragColor, ViewTintColor, ViewTintColor.a);\n"
 713 "#endif\n"
 714 "\n"
 715 "#ifdef USEPOSTPROCESSING\n"
 716 "// do r_glsl_dumpshader, edit glsl/default.glsl, and replace this by your own postprocessing if you want\n"
 717 "// 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"
 718 "       float sobel = 1.0;\n"
 719 "       // vec2 ts = textureSize(Texture_First, 0);\n"
 720 "       // vec2 px = vec2(1/ts.x, 1/ts.y);\n"
 721 "       vec2 px = PixelSize;\n"
 722 "       vec3 x1 = texture2D(Texture_First, TexCoord1 + vec2(-px.x, px.y)).rgb;\n"
 723 "       vec3 x2 = texture2D(Texture_First, TexCoord1 + vec2(-px.x,  0.0)).rgb;\n"
 724 "       vec3 x3 = texture2D(Texture_First, TexCoord1 + vec2(-px.x,-px.y)).rgb;\n"
 725 "       vec3 x4 = texture2D(Texture_First, TexCoord1 + vec2( px.x, px.y)).rgb;\n"
 726 "       vec3 x5 = texture2D(Texture_First, TexCoord1 + vec2( px.x,  0.0)).rgb;\n"
 727 "       vec3 x6 = texture2D(Texture_First, TexCoord1 + vec2( px.x,-px.y)).rgb;\n"
 728 "       vec3 y1 = texture2D(Texture_First, TexCoord1 + vec2( px.x,-px.y)).rgb;\n"
 729 "       vec3 y2 = texture2D(Texture_First, TexCoord1 + vec2(  0.0,-px.y)).rgb;\n"
 730 "       vec3 y3 = texture2D(Texture_First, TexCoord1 + vec2(-px.x,-px.y)).rgb;\n"
 731 "       vec3 y4 = texture2D(Texture_First, TexCoord1 + vec2( px.x, px.y)).rgb;\n"
 732 "       vec3 y5 = texture2D(Texture_First, TexCoord1 + vec2(  0.0, px.y)).rgb;\n"
 733 "       vec3 y6 = texture2D(Texture_First, TexCoord1 + vec2(-px.x, px.y)).rgb;\n"
 734 "       float px1 = -1.0 * dot(vec3(0.3, 0.59, 0.11), x1);\n"
 735 "       float px2 = -2.0 * dot(vec3(0.3, 0.59, 0.11), x2);\n"
 736 "       float px3 = -1.0 * dot(vec3(0.3, 0.59, 0.11), x3);\n"
 737 "       float px4 =  1.0 * dot(vec3(0.3, 0.59, 0.11), x4);\n"
 738 "       float px5 =  2.0 * dot(vec3(0.3, 0.59, 0.11), x5);\n"
 739 "       float px6 =  1.0 * dot(vec3(0.3, 0.59, 0.11), x6);\n"
 740 "       float py1 = -1.0 * dot(vec3(0.3, 0.59, 0.11), y1);\n"
 741 "       float py2 = -2.0 * dot(vec3(0.3, 0.59, 0.11), y2);\n"
 742 "       float py3 = -1.0 * dot(vec3(0.3, 0.59, 0.11), y3);\n"
 743 "       float py4 =  1.0 * dot(vec3(0.3, 0.59, 0.11), y4);\n"
 744 "       float py5 =  2.0 * dot(vec3(0.3, 0.59, 0.11), y5);\n"
 745 "       float py6 =  1.0 * dot(vec3(0.3, 0.59, 0.11), y6);\n"
 746 "       sobel = 0.25 * abs(px1 + px2 + px3 + px4 + px5 + px6) + 0.25 * abs(py1 + py2 + py3 + py4 + py5 + py6);\n"
 747 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2(-0.987688, -0.156434)) * UserVec1.y;\n"
 748 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2(-0.156434, -0.891007)) * UserVec1.y;\n"
 749 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2( 0.891007, -0.453990)) * UserVec1.y;\n"
 750 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2( 0.707107,  0.707107)) * UserVec1.y;\n"
 751 "       gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2(-0.453990,  0.891007)) * UserVec1.y;\n"
 752 "       gl_FragColor /= (1.0 + 5.0 * UserVec1.y);\n"
 753 "       gl_FragColor.rgb = gl_FragColor.rgb * (1.0 + UserVec2.x) + vec3(max(0.0, sobel - UserVec2.z))*UserVec2.y;\n"
 754 "#endif\n"
 755 "\n"
 756 "#ifdef USESATURATION\n"
 757 "       //apply saturation BEFORE gamma ramps, so v_glslgamma value does not matter\n"
 758 "       float y = dot(gl_FragColor.rgb, vec3(0.299, 0.587, 0.114));\n"
 759 "       // 'vampire sight' effect, wheres red is compensated\n"
 760 "       #ifdef SATURATION_REDCOMPENSATE\n"
 761 "               float rboost = max(0.0, (gl_FragColor.r - max(gl_FragColor.g, gl_FragColor.b))*(1.0 - Saturation));\n"
 762 "               gl_FragColor.rgb = mix(vec3(y), gl_FragColor.rgb, Saturation);\n"
 763 "               gl_FragColor.r += rboost;\n"
 764 "       #else\n"
 765 "               // normal desaturation\n"
 766 "               //gl_FragColor = vec3(y) + (gl_FragColor.rgb - vec3(y)) * Saturation;\n"
 767 "               gl_FragColor.rgb = mix(vec3(y), gl_FragColor.rgb, Saturation);\n"
 768 "       #endif\n"
 769 "#endif\n"
 770 "\n"
 771 "#ifdef USEGAMMARAMPS\n"
 772 "       gl_FragColor.r = texture2D(Texture_GammaRamps, vec2(gl_FragColor.r, 0)).r;\n"
 773 "       gl_FragColor.g = texture2D(Texture_GammaRamps, vec2(gl_FragColor.g, 0)).g;\n"
 774 "       gl_FragColor.b = texture2D(Texture_GammaRamps, vec2(gl_FragColor.b, 0)).b;\n"
 775 "#endif\n"
 776 "}\n"
 777 "#endif\n"
 778 "#else // !MODE_POSTPROCESS\n"
 779 "\n"
 780 "\n"
 781 "\n"
 782 "\n"
 783 "#ifdef MODE_GENERIC\n"
 784 "#ifdef USEDIFFUSE\n"
 785 "varying vec2 TexCoord1;\n"
 786 "#endif\n"
 787 "#ifdef USESPECULAR\n"
 788 "varying vec2 TexCoord2;\n"
 789 "#endif\n"
 790 "#ifdef VERTEX_SHADER\n"
 791 "void main(void)\n"
 792 "{\n"
 793 "       gl_FrontColor = gl_Color;\n"
 794 "#ifdef USEDIFFUSE\n"
 795 "       TexCoord1 = gl_MultiTexCoord0.xy;\n"
 796 "#endif\n"
 797 "#ifdef USESPECULAR\n"
 798 "       TexCoord2 = gl_MultiTexCoord1.xy;\n"
 799 "#endif\n"
 800 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 801 "}\n"
 802 "#endif\n"
 803 "\n"
 804 "#ifdef FRAGMENT_SHADER\n"
 805 "#ifdef USEDIFFUSE\n"
 806 "uniform sampler2D Texture_First;\n"
 807 "#endif\n"
 808 "#ifdef USESPECULAR\n"
 809 "uniform sampler2D Texture_Second;\n"
 810 "#endif\n"
 811 "\n"
 812 "void main(void)\n"
 813 "{\n"
 814 "#ifdef USEVIEWTINT\n"
 815 "       gl_FragColor = gl_Color;\n"
 816 "#else\n"
 817 "       gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);\n"
 818 "#endif\n"
 819 "#ifdef USEDIFFUSE\n"
 820 "       gl_FragColor *= texture2D(Texture_First, TexCoord1);\n"
 821 "#endif\n"
 822 "\n"
 823 "#ifdef USESPECULAR\n"
 824 "       vec4 tex2 = texture2D(Texture_Second, TexCoord2);\n"
 825 "# ifdef USECOLORMAPPING\n"
 826 "       gl_FragColor *= tex2;\n"
 827 "# endif\n"
 828 "# ifdef USEGLOW\n"
 829 "       gl_FragColor += tex2;\n"
 830 "# endif\n"
 831 "# ifdef USEVERTEXTEXTUREBLEND\n"
 832 "       gl_FragColor = mix(gl_FragColor, tex2, tex2.a);\n"
 833 "# endif\n"
 834 "#endif\n"
 835 "}\n"
 836 "#endif\n"
 837 "#else // !MODE_GENERIC\n"
 838 "\n"
 839 "\n"
 840 "\n"
 841 "\n"
 842 "#ifdef MODE_BLOOMBLUR\n"
 843 "varying TexCoord;\n"
 844 "#ifdef VERTEX_SHADER\n"
 845 "void main(void)\n"
 846 "{\n"
 847 "       gl_FrontColor = gl_Color;\n"
 848 "       TexCoord = gl_MultiTexCoord0.xy;\n"
 849 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 850 "}\n"
 851 "#endif\n"
 852 "\n"
 853 "#ifdef FRAGMENT_SHADER\n"
 854 "uniform sampler2D Texture_First;\n"
 855 "uniform vec4 BloomBlur_Parameters;\n"
 856 "\n"
 857 "void main(void)\n"
 858 "{\n"
 859 "       int i;\n"
 860 "       vec2 tc = TexCoord;\n"
 861 "       vec3 color = texture2D(Texture_First, tc).rgb;\n"
 862 "       tc += BloomBlur_Parameters.xy;\n"
 863 "       for (i = 1;i < SAMPLES;i++)\n"
 864 "       {\n"
 865 "               color += texture2D(Texture_First, tc).rgb;\n"
 866 "               tc += BloomBlur_Parameters.xy;\n"
 867 "       }\n"
 868 "       gl_FragColor = vec4(color * BloomBlur_Parameters.z + vec3(BloomBlur_Parameters.w), 1);\n"
 869 "}\n"
 870 "#endif\n"
 871 "#else // !MODE_BLOOMBLUR\n"
 872 "#ifdef MODE_REFRACTION\n"
 873 "varying vec2 TexCoord;\n"
 874 "varying vec4 ModelViewProjectionPosition;\n"
 875 "uniform mat4 TexMatrix;\n"
 876 "#ifdef VERTEX_SHADER\n"
 877 "\n"
 878 "void main(void)\n"
 879 "{\n"
 880 "       TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
 881 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 882 "       ModelViewProjectionPosition = gl_Position;\n"
 883 "}\n"
 884 "#endif\n"
 885 "\n"
 886 "#ifdef FRAGMENT_SHADER\n"
 887 "uniform sampler2D Texture_Normal;\n"
 888 "uniform sampler2D Texture_Refraction;\n"
 889 "uniform sampler2D Texture_Reflection;\n"
 890 "\n"
 891 "uniform vec4 DistortScaleRefractReflect;\n"
 892 "uniform vec4 ScreenScaleRefractReflect;\n"
 893 "uniform vec4 ScreenCenterRefractReflect;\n"
 894 "uniform vec4 RefractColor;\n"
 895 "uniform vec4 ReflectColor;\n"
 896 "uniform float ReflectFactor;\n"
 897 "uniform float ReflectOffset;\n"
 898 "\n"
 899 "void main(void)\n"
 900 "{\n"
 901 "       vec2 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect.xy * (1.0 / ModelViewProjectionPosition.w);\n"
 902 "       //vec2 ScreenTexCoord = (ModelViewProjectionPosition.xy + normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5)).xy * DistortScaleRefractReflect.xy * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
 903 "       vec2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
 904 "       vec2 ScreenTexCoord = SafeScreenTexCoord + vec2(normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5))).xy * DistortScaleRefractReflect.xy;\n"
 905 "       // FIXME temporary hack to detect the case that the reflection\n"
 906 "       // gets blackened at edges due to leaving the area that contains actual\n"
 907 "       // content.\n"
 908 "       // Remove this 'ack once we have a better way to stop this thing from\n"
 909 "       // 'appening.\n"
 910 "       float f = min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(0.01, 0.01)).rgb) / 0.05);\n"
 911 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(0.01, -0.01)).rgb) / 0.05);\n"
 912 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
 913 "       f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
 914 "       ScreenTexCoord = mix(SafeScreenTexCoord, ScreenTexCoord, f);\n"
 915 "       gl_FragColor = vec4(texture2D(Texture_Refraction, ScreenTexCoord).rgb, 1.0) * RefractColor;\n"
 916 "}\n"
 917 "#endif\n"
 918 "#else // !MODE_REFRACTION\n"
 919 "\n"
 920 "\n"
 921 "\n"
 922 "\n"
 923 "#ifdef MODE_WATER\n"
 924 "varying vec2 TexCoord;\n"
 925 "varying vec3 EyeVector;\n"
 926 "varying vec4 ModelViewProjectionPosition;\n"
 927 "#ifdef VERTEX_SHADER\n"
 928 "uniform vec3 EyePosition;\n"
 929 "uniform mat4 TexMatrix;\n"
 930 "\n"
 931 "void main(void)\n"
 932 "{\n"
 933 "       TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
 934 "       vec3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
 935 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
 936 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
 937 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
 938 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
 939 "       ModelViewProjectionPosition = gl_Position;\n"
 940 "}\n"
 941 "#endif\n"
 942 "\n"
 943 "#ifdef FRAGMENT_SHADER\n"
 944 "uniform sampler2D Texture_Normal;\n"
 945 "uniform sampler2D Texture_Refraction;\n"
 946 "uniform sampler2D Texture_Reflection;\n"
 947 "\n"
 948 "uniform vec4 DistortScaleRefractReflect;\n"
 949 "uniform vec4 ScreenScaleRefractReflect;\n"
 950 "uniform vec4 ScreenCenterRefractReflect;\n"
 951 "uniform vec4 RefractColor;\n"
 952 "uniform vec4 ReflectColor;\n"
 953 "uniform float ReflectFactor;\n"
 954 "uniform float ReflectOffset;\n"
 955 "uniform float ClientTime;\n"
 956 "#ifdef USENORMALMAPSCROLLBLEND\n"
 957 "uniform vec2 NormalmapScrollBlend;\n"
 958 "#endif\n"
 959 "\n"
 960 "void main(void)\n"
 961 "{\n"
 962 "       vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
 963 "       //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
 964 "       vec4 SafeScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
 965 "       //SafeScreenTexCoord = gl_FragCoord.xyxy * vec4(1.0 / 1920.0, 1.0 / 1200.0, 1.0 / 1920.0, 1.0 / 1200.0);\n"
 966 "       // slight water animation via 2 layer scrolling (todo: tweak)\n"
 967 "       #ifdef USENORMALMAPSCROLLBLEND\n"
 968 "               vec3 normal = texture2D(Texture_Normal, (TexCoord + vec2(0.08, 0.08)*ClientTime*NormalmapScrollBlend.x*0.5)*NormalmapScrollBlend.y).rgb - vec3(1.0);\n"
 969 "               normal += texture2D(Texture_Normal, (TexCoord + vec2(-0.06, -0.09)*ClientTime*NormalmapScrollBlend.x)*NormalmapScrollBlend.y*0.75).rgb;\n"
 970 "               vec4 ScreenTexCoord = SafeScreenTexCoord + vec2(normalize(normal) + vec3(0.15)).xyxy * DistortScaleRefractReflect;\n"
 971 "       #else\n"
 972 "               vec4 ScreenTexCoord = SafeScreenTexCoord + vec2(normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5))).xyxy * DistortScaleRefractReflect;\n"
 973 "       #endif\n"
 974 "       // FIXME temporary hack to detect the case that the reflection\n"
 975 "       // gets blackened at edges due to leaving the area that contains actual\n"
 976 "       // content.\n"
 977 "       // Remove this 'ack once we have a better way to stop this thing from\n"
 978 "       // 'appening.\n"
 979 "       float f  = min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(0.005, 0.01)).rgb) / 0.002);\n"
 980 "       f       *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(0.005, -0.01)).rgb) / 0.002);\n"
 981 "       f       *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(-0.005, 0.01)).rgb) / 0.002);\n"
 982 "       f       *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(-0.005, -0.01)).rgb) / 0.002);\n"
 983 "       ScreenTexCoord.xy = mix(SafeScreenTexCoord.xy, ScreenTexCoord.xy, f);\n"
 984 "       f  = min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(0.005, 0.005)).rgb) / 0.002);\n"
 985 "       f *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(0.005, -0.005)).rgb) / 0.002);\n"
 986 "       f *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(-0.005, 0.005)).rgb) / 0.002);\n"
 987 "       f *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(-0.005, -0.005)).rgb) / 0.002);\n"
 988 "       ScreenTexCoord.zw = mix(SafeScreenTexCoord.zw, ScreenTexCoord.zw, f);\n"
 989 "       float Fresnel = pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 2.0) * ReflectFactor + ReflectOffset;\n"
 990 "       gl_FragColor = mix(vec4(texture2D(Texture_Refraction, ScreenTexCoord.xy).rgb, 1) * RefractColor, vec4(texture2D(Texture_Reflection, ScreenTexCoord.zw).rgb, 1) * ReflectColor, Fresnel);\n"
 991 "}\n"
 992 "#endif\n"
 993 "#else // !MODE_WATER\n"
 994 "\n"
 995 "\n"
 996 "\n"
 997 "\n"
 998 "// common definitions between vertex shader and fragment shader:\n"
 999 "\n"
1000 "varying vec2 TexCoord;\n"
1001 "#ifdef USEVERTEXTEXTUREBLEND\n"
1002 "varying vec2 TexCoord2;\n"
1003 "#endif\n"
1004 "#ifdef USELIGHTMAP\n"
1005 "varying vec2 TexCoordLightmap;\n"
1006 "#endif\n"
1007 "\n"
1008 "#ifdef MODE_LIGHTSOURCE\n"
1009 "varying vec3 CubeVector;\n"
1010 "#endif\n"
1011 "\n"
1012 "#if (defined(MODE_LIGHTSOURCE) || defined(MODE_LIGHTDIRECTION)) && defined(USEDIFFUSE)\n"
1013 "varying vec3 LightVector;\n"
1014 "#endif\n"
1015 "\n"
1016 "#ifdef USEEYEVECTOR\n"
1017 "varying vec3 EyeVector;\n"
1018 "#endif\n"
1019 "#ifdef USEFOG\n"
1020 "varying vec4 EyeVectorModelSpaceFogPlaneVertexDist;\n"
1021 "#endif\n"
1022 "\n"
1023 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY) || defined(USEREFLECTCUBE)\n"
1024 "varying vec3 VectorS; // direction of S texcoord (sometimes crudely called tangent)\n"
1025 "varying vec3 VectorT; // direction of T texcoord (sometimes crudely called binormal)\n"
1026 "varying vec3 VectorR; // direction of R texcoord (surface normal)\n"
1027 "#endif\n"
1028 "\n"
1029 "#ifdef USEREFLECTION\n"
1030 "varying vec4 ModelViewProjectionPosition;\n"
1031 "#endif\n"
1032 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
1033 "uniform vec3 LightPosition;\n"
1034 "varying vec4 ModelViewPosition;\n"
1035 "#endif\n"
1036 "\n"
1037 "#ifdef MODE_LIGHTSOURCE\n"
1038 "uniform vec3 LightPosition;\n"
1039 "#endif\n"
1040 "uniform vec3 EyePosition;\n"
1041 "#ifdef MODE_LIGHTDIRECTION\n"
1042 "uniform vec3 LightDir;\n"
1043 "#endif\n"
1044 "uniform vec4 FogPlane;\n"
1045 "\n"
1046 "#ifdef USESHADOWMAPORTHO\n"
1047 "varying vec3 ShadowMapTC;\n"
1048 "#endif\n"
1049 "\n"
1050 "\n"
1051 "\n"
1052 "\n"
1053 "\n"
1054 "// 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"
1055 "\n"
1056 "// fragment shader specific:\n"
1057 "#ifdef FRAGMENT_SHADER\n"
1058 "\n"
1059 "uniform sampler2D Texture_Normal;\n"
1060 "uniform sampler2D Texture_Color;\n"
1061 "uniform sampler2D Texture_Gloss;\n"
1062 "#ifdef USEGLOW\n"
1063 "uniform sampler2D Texture_Glow;\n"
1064 "#endif\n"
1065 "#ifdef USEVERTEXTEXTUREBLEND\n"
1066 "uniform sampler2D Texture_SecondaryNormal;\n"
1067 "uniform sampler2D Texture_SecondaryColor;\n"
1068 "uniform sampler2D Texture_SecondaryGloss;\n"
1069 "#ifdef USEGLOW\n"
1070 "uniform sampler2D Texture_SecondaryGlow;\n"
1071 "#endif\n"
1072 "#endif\n"
1073 "#ifdef USECOLORMAPPING\n"
1074 "uniform sampler2D Texture_Pants;\n"
1075 "uniform sampler2D Texture_Shirt;\n"
1076 "#endif\n"
1077 "#ifdef USEFOG\n"
1078 "#ifdef USEFOGHEIGHTTEXTURE\n"
1079 "uniform sampler2D Texture_FogHeightTexture;\n"
1080 "#endif\n"
1081 "uniform sampler2D Texture_FogMask;\n"
1082 "#endif\n"
1083 "#ifdef USELIGHTMAP\n"
1084 "uniform sampler2D Texture_Lightmap;\n"
1085 "#endif\n"
1086 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
1087 "uniform sampler2D Texture_Deluxemap;\n"
1088 "#endif\n"
1089 "#ifdef USEREFLECTION\n"
1090 "uniform sampler2D Texture_Reflection;\n"
1091 "#endif\n"
1092 "\n"
1093 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
1094 "uniform sampler2D Texture_ScreenDepth;\n"
1095 "uniform sampler2D Texture_ScreenNormalMap;\n"
1096 "#endif\n"
1097 "#ifdef USEDEFERREDLIGHTMAP\n"
1098 "uniform sampler2D Texture_ScreenDiffuse;\n"
1099 "uniform sampler2D Texture_ScreenSpecular;\n"
1100 "#endif\n"
1101 "\n"
1102 "uniform myhalf3 Color_Pants;\n"
1103 "uniform myhalf3 Color_Shirt;\n"
1104 "uniform myhalf3 FogColor;\n"
1105 "\n"
1106 "#ifdef USEFOG\n"
1107 "uniform float FogRangeRecip;\n"
1108 "uniform float FogPlaneViewDist;\n"
1109 "uniform float FogHeightFade;\n"
1110 "vec3 FogVertex(vec3 surfacecolor)\n"
1111 "{\n"
1112 "       vec3 EyeVectorModelSpace = EyeVectorModelSpaceFogPlaneVertexDist.xyz;\n"
1113 "       float FogPlaneVertexDist = EyeVectorModelSpaceFogPlaneVertexDist.w;\n"
1114 "       float fogfrac;\n"
1115 "#ifdef USEFOGHEIGHTTEXTURE\n"
1116 "       vec4 fogheightpixel = texture2D(Texture_FogHeightTexture, vec2(1,1) + vec2(FogPlaneVertexDist, FogPlaneViewDist) * (-2.0 * FogHeightFade));\n"
1117 "       fogfrac = fogheightpixel.a;\n"
1118 "       return mix(fogheightpixel.rgb * FogColor, surfacecolor, texture2D(Texture_FogMask, myhalf2(length(EyeVectorModelSpace)*fogfrac*FogRangeRecip, 0.0)).r);\n"
1119 "#else\n"
1120 "# ifdef USEFOGOUTSIDE\n"
1121 "       fogfrac = min(0.0, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0, min(0.0, FogPlaneVertexDist) * FogHeightFade);\n"
1122 "# else\n"
1123 "       fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0, FogPlaneVertexDist)) * min(1.0, (min(0.0, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);\n"
1124 "# endif\n"
1125 "       return mix(FogColor, surfacecolor, texture2D(Texture_FogMask, myhalf2(length(EyeVectorModelSpace)*fogfrac*FogRangeRecip, 0.0)).r);\n"
1126 "#endif\n"
1127 "}\n"
1128 "#endif\n"
1129 "\n"
1130 "#ifdef USEOFFSETMAPPING\n"
1131 "uniform float OffsetMapping_Scale;\n"
1132 "vec2 OffsetMapping(vec2 TexCoord)\n"
1133 "{\n"
1134 "#ifdef USEOFFSETMAPPING_RELIEFMAPPING\n"
1135 "       // 14 sample relief mapping: linear search and then binary search\n"
1136 "       // this basically steps forward a small amount repeatedly until it finds\n"
1137 "       // itself inside solid, then jitters forward and back using decreasing\n"
1138 "       // amounts to find the impact\n"
1139 "       //vec3 OffsetVector = vec3(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1), -1);\n"
1140 "       //vec3 OffsetVector = vec3(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
1141 "       vec3 OffsetVector = vec3(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
1142 "       vec3 RT = vec3(TexCoord, 1);\n"
1143 "       OffsetVector *= 0.1;\n"
1144 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1145 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1146 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1147 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1148 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1149 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1150 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1151 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1152 "       RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1153 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z)          - 0.5);\n"
1154 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.5    - 0.25);\n"
1155 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.25   - 0.125);\n"
1156 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.125  - 0.0625);\n"
1157 "       RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.0625 - 0.03125);\n"
1158 "       return RT.xy;\n"
1159 "#else\n"
1160 "       // 2 sample offset mapping (only 2 samples because of ATI Radeon 9500-9800/X300 limits)\n"
1161 "       // this basically moves forward the full distance, and then backs up based\n"
1162 "       // on height of samples\n"
1163 "       //vec2 OffsetVector = vec2(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1));\n"
1164 "       //vec2 OffsetVector = vec2(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1));\n"
1165 "       vec2 OffsetVector = vec2(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1));\n"
1166 "       TexCoord += OffsetVector;\n"
1167 "       OffsetVector *= 0.5;\n"
1168 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
1169 "       TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
1170 "       return TexCoord;\n"
1171 "#endif\n"
1172 "}\n"
1173 "#endif // USEOFFSETMAPPING\n"
1174 "\n"
1175 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE)\n"
1176 "uniform sampler2D Texture_Attenuation;\n"
1177 "uniform samplerCube Texture_Cube;\n"
1178 "#endif\n"
1179 "\n"
1180 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USESHADOWMAPORTHO)\n"
1181 "\n"
1182 "#ifdef USESHADOWMAP2D\n"
1183 "# ifdef USESHADOWSAMPLER\n"
1184 "uniform sampler2DShadow Texture_ShadowMap2D;\n"
1185 "# else\n"
1186 "uniform sampler2D Texture_ShadowMap2D;\n"
1187 "# endif\n"
1188 "#endif\n"
1189 "\n"
1190 "#ifdef USESHADOWMAPVSDCT\n"
1191 "uniform samplerCube Texture_CubeProjection;\n"
1192 "#endif\n"
1193 "\n"
1194 "#if defined(USESHADOWMAP2D)\n"
1195 "uniform vec2 ShadowMap_TextureScale;\n"
1196 "uniform vec4 ShadowMap_Parameters;\n"
1197 "#endif\n"
1198 "\n"
1199 "#if defined(USESHADOWMAP2D)\n"
1200 "# ifdef USESHADOWMAPORTHO\n"
1201 "#  define GetShadowMapTC2D(dir) (min(dir, ShadowMap_Parameters.xyz))\n"
1202 "# else\n"
1203 "#  ifdef USESHADOWMAPVSDCT\n"
1204 "vec3 GetShadowMapTC2D(vec3 dir)\n"
1205 "{\n"
1206 "       vec3 adir = abs(dir);\n"
1207 "       vec2 aparams = ShadowMap_Parameters.xy / max(max(adir.x, adir.y), adir.z);\n"
1208 "       vec4 proj = textureCube(Texture_CubeProjection, dir);\n"
1209 "       return vec3(mix(dir.xy, dir.zz, proj.xy) * aparams.x + proj.zw * ShadowMap_Parameters.z, aparams.y + ShadowMap_Parameters.w);\n"
1210 "}\n"
1211 "#  else\n"
1212 "vec3 GetShadowMapTC2D(vec3 dir)\n"
1213 "{\n"
1214 "       vec3 adir = abs(dir);\n"
1215 "       float ma = adir.z;\n"
1216 "       vec4 proj = vec4(dir, 2.5);\n"
1217 "       if (adir.x > ma) { ma = adir.x; proj = vec4(dir.zyx, 0.5); }\n"
1218 "       if (adir.y > ma) { ma = adir.y; proj = vec4(dir.xzy, 1.5); }\n"
1219 "       vec2 aparams = ShadowMap_Parameters.xy / ma;\n"
1220 "       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"
1221 "}\n"
1222 "#  endif\n"
1223 "# endif\n"
1224 "#endif // defined(USESHADOWMAP2D)\n"
1225 "\n"
1226 "# ifdef USESHADOWMAP2D\n"
1227 "float ShadowMapCompare(vec3 dir)\n"
1228 "{\n"
1229 "       vec3 shadowmaptc = GetShadowMapTC2D(dir);\n"
1230 "       float f;\n"
1231 "\n"
1232 "#  ifdef USESHADOWSAMPLER\n"
1233 "#    ifdef USESHADOWMAPPCF\n"
1234 "#      define texval(x, y) shadow2D(Texture_ShadowMap2D, vec3(center + vec2(x, y)*ShadowMap_TextureScale, shadowmaptc.z)).r  \n"
1235 "       vec2 center = shadowmaptc.xy*ShadowMap_TextureScale;\n"
1236 "       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"
1237 "#    else\n"
1238 "       f = shadow2D(Texture_ShadowMap2D, vec3(shadowmaptc.xy*ShadowMap_TextureScale, shadowmaptc.z)).r;\n"
1239 "#    endif\n"
1240 "#  else\n"
1241 "#    ifdef USESHADOWMAPPCF\n"
1242 "#     if defined(GL_ARB_texture_gather) || defined(GL_AMD_texture_texture4)\n"
1243 "#      ifdef GL_ARB_texture_gather\n"
1244 "#        define texval(x, y) textureGatherOffset(Texture_ShadowMap2D, center, ivec2(x, y))\n"
1245 "#      else\n"
1246 "#        define texval(x, y) texture4(Texture_ShadowMap2D, center + vec2(x, y)*ShadowMap_TextureScale)\n"
1247 "#      endif\n"
1248 "       vec2 offset = fract(shadowmaptc.xy - 0.5), center = (shadowmaptc.xy - offset)*ShadowMap_TextureScale;\n"
1249 "#      if USESHADOWMAPPCF > 1\n"
1250 "   vec4 group1 = step(shadowmaptc.z, texval(-2.0, -2.0));\n"
1251 "   vec4 group2 = step(shadowmaptc.z, texval( 0.0, -2.0));\n"
1252 "   vec4 group3 = step(shadowmaptc.z, texval( 2.0, -2.0));\n"
1253 "   vec4 group4 = step(shadowmaptc.z, texval(-2.0,  0.0));\n"
1254 "   vec4 group5 = step(shadowmaptc.z, texval( 0.0,  0.0));\n"
1255 "   vec4 group6 = step(shadowmaptc.z, texval( 2.0,  0.0));\n"
1256 "   vec4 group7 = step(shadowmaptc.z, texval(-2.0,  2.0));\n"
1257 "   vec4 group8 = step(shadowmaptc.z, texval( 0.0,  2.0));\n"
1258 "   vec4 group9 = step(shadowmaptc.z, texval( 2.0,  2.0));\n"
1259 "       vec4 locols = vec4(group1.ab, group3.ab);\n"
1260 "       vec4 hicols = vec4(group7.rg, group9.rg);\n"
1261 "       locols.yz += group2.ab;\n"
1262 "       hicols.yz += group8.rg;\n"
1263 "       vec4 midcols = vec4(group1.rg, group3.rg) + vec4(group7.ab, group9.ab) +\n"
1264 "                               vec4(group4.rg, group6.rg) + vec4(group4.ab, group6.ab) +\n"
1265 "                               mix(locols, hicols, offset.y);\n"
1266 "       vec4 cols = group5 + vec4(group2.rg, group8.ab);\n"
1267 "       cols.xyz += mix(midcols.xyz, midcols.yzw, offset.x);\n"
1268 "       f = dot(cols, vec4(1.0/25.0));\n"
1269 "#      else\n"
1270 "       vec4 group1 = step(shadowmaptc.z, texval(-1.0, -1.0));\n"
1271 "       vec4 group2 = step(shadowmaptc.z, texval( 1.0, -1.0));\n"
1272 "       vec4 group3 = step(shadowmaptc.z, texval(-1.0,  1.0));\n"
1273 "       vec4 group4 = step(shadowmaptc.z, texval( 1.0,  1.0));\n"
1274 "       vec4 cols = vec4(group1.rg, group2.rg) + vec4(group3.ab, group4.ab) +\n"
1275 "                               mix(vec4(group1.ab, group2.ab), vec4(group3.rg, group4.rg), offset.y);\n"
1276 "       f = dot(mix(cols.xyz, cols.yzw, offset.x), vec3(1.0/9.0));\n"
1277 "#      endif\n"
1278 "#     else\n"
1279 "#      ifdef GL_EXT_gpu_shader4\n"
1280 "#        define texval(x, y) texture2DOffset(Texture_ShadowMap2D, center, ivec2(x, y)).r\n"
1281 "#      else\n"
1282 "#        define texval(x, y) texture2D(Texture_ShadowMap2D, center + vec2(x, y)*ShadowMap_TextureScale).r  \n"
1283 "#      endif\n"
1284 "#      if USESHADOWMAPPCF > 1\n"
1285 "       vec2 center = shadowmaptc.xy - 0.5, offset = fract(center);\n"
1286 "       center *= ShadowMap_TextureScale;\n"
1287 "       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"
1288 "       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"
1289 "       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"
1290 "       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"
1291 "       vec4 cols = row2 + row3 + mix(row1, row4, offset.y);\n"
1292 "       f = dot(mix(cols.xyz, cols.yzw, offset.x), vec3(1.0/9.0));\n"
1293 "#      else\n"
1294 "       vec2 center = shadowmaptc.xy*ShadowMap_TextureScale, offset = fract(shadowmaptc.xy);\n"
1295 "       vec3 row1 = step(shadowmaptc.z, vec3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n"
1296 "       vec3 row2 = step(shadowmaptc.z, vec3(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0)));\n"
1297 "       vec3 row3 = step(shadowmaptc.z, vec3(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0)));\n"
1298 "       vec3 cols = row2 + mix(row1, row3, offset.y);\n"
1299 "       f = dot(mix(cols.xy, cols.yz, offset.x), vec2(0.25));\n"
1300 "#      endif\n"
1301 "#     endif\n"
1302 "#    else\n"
1303 "       f = step(shadowmaptc.z, texture2D(Texture_ShadowMap2D, shadowmaptc.xy*ShadowMap_TextureScale).r);\n"
1304 "#    endif\n"
1305 "#  endif\n"
1306 "#  ifdef USESHADOWMAPORTHO\n"
1307 "       return mix(ShadowMap_Parameters.w, 1.0, f);\n"
1308 "#  else\n"
1309 "       return f;\n"
1310 "#  endif\n"
1311 "}\n"
1312 "# endif\n"
1313 "#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE) && !defined(USESHADOWMAPORTHO)\n"
1314 "#endif // FRAGMENT_SHADER\n"
1315 "\n"
1316 "\n"
1317 "\n"
1318 "\n"
1319 "#ifdef MODE_DEFERREDGEOMETRY\n"
1320 "#ifdef VERTEX_SHADER\n"
1321 "uniform mat4 TexMatrix;\n"
1322 "#ifdef USEVERTEXTEXTUREBLEND\n"
1323 "uniform mat4 BackgroundTexMatrix;\n"
1324 "#endif\n"
1325 "uniform mat4 ModelViewMatrix;\n"
1326 "void main(void)\n"
1327 "{\n"
1328 "       TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
1329 "#ifdef USEVERTEXTEXTUREBLEND\n"
1330 "       gl_FrontColor = gl_Color;\n"
1331 "       TexCoord2 = vec2(BackgroundTexMatrix * gl_MultiTexCoord0);\n"
1332 "#endif\n"
1333 "\n"
1334 "       // transform unnormalized eye direction into tangent space\n"
1335 "#ifdef USEOFFSETMAPPING\n"
1336 "       vec3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
1337 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
1338 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
1339 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
1340 "#endif\n"
1341 "\n"
1342 "       VectorS = (ModelViewMatrix * vec4(gl_MultiTexCoord1.xyz, 0)).xyz;\n"
1343 "       VectorT = (ModelViewMatrix * vec4(gl_MultiTexCoord2.xyz, 0)).xyz;\n"
1344 "       VectorR = (ModelViewMatrix * vec4(gl_MultiTexCoord3.xyz, 0)).xyz;\n"
1345 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
1346 "}\n"
1347 "#endif // VERTEX_SHADER\n"
1348 "\n"
1349 "#ifdef FRAGMENT_SHADER\n"
1350 "void main(void)\n"
1351 "{\n"
1352 "#ifdef USEOFFSETMAPPING\n"
1353 "       // apply offsetmapping\n"
1354 "       vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
1355 "#define TexCoord TexCoordOffset\n"
1356 "#endif\n"
1357 "\n"
1358 "#ifdef USEALPHAKILL\n"
1359 "       if (texture2D(Texture_Color, TexCoord).a < 0.5)\n"
1360 "               discard;\n"
1361 "#endif\n"
1362 "\n"
1363 "#ifdef USEVERTEXTEXTUREBLEND\n"
1364 "       float alpha = texture2D(Texture_Color, TexCoord).a;\n"
1365 "       float terrainblend = clamp(float(gl_Color.a) * alpha * 2.0 - 0.5, float(0.0), float(1.0));\n"
1366 "       //float terrainblend = min(float(gl_Color.a) * alpha * 2.0, float(1.0));\n"
1367 "       //float terrainblend = float(gl_Color.a) * alpha > 0.5;\n"
1368 "#endif\n"
1369 "\n"
1370 "#ifdef USEVERTEXTEXTUREBLEND\n"
1371 "       vec3 surfacenormal = mix(vec3(texture2D(Texture_SecondaryNormal, TexCoord2)), vec3(texture2D(Texture_Normal, TexCoord)), terrainblend) - vec3(0.5, 0.5, 0.5);\n"
1372 "       float a = mix(texture2D(Texture_SecondaryGloss, TexCoord2).a, texture2D(Texture_Gloss, TexCoord).a, terrainblend);\n"
1373 "#else\n"
1374 "       vec3 surfacenormal = vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5, 0.5, 0.5);\n"
1375 "       float a = texture2D(Texture_Gloss, TexCoord).a;\n"
1376 "#endif\n"
1377 "\n"
1378 "       gl_FragColor = vec4(normalize(surfacenormal.x * VectorS + surfacenormal.y * VectorT + surfacenormal.z * VectorR) * 0.5 + vec3(0.5, 0.5, 0.5), a);\n"
1379 "}\n"
1380 "#endif // FRAGMENT_SHADER\n"
1381 "#else // !MODE_DEFERREDGEOMETRY\n"
1382 "\n"
1383 "\n"
1384 "\n"
1385 "\n"
1386 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
1387 "#ifdef VERTEX_SHADER\n"
1388 "uniform mat4 ModelViewMatrix;\n"
1389 "void main(void)\n"
1390 "{\n"
1391 "       ModelViewPosition = ModelViewMatrix * gl_Vertex;\n"
1392 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
1393 "}\n"
1394 "#endif // VERTEX_SHADER\n"
1395 "\n"
1396 "#ifdef FRAGMENT_SHADER\n"
1397 "uniform mat4 ViewToLight;\n"
1398 "// ScreenToDepth = vec2(Far / (Far - Near), Far * Near / (Near - Far));\n"
1399 "uniform vec2 ScreenToDepth;\n"
1400 "uniform myhalf3 DeferredColor_Ambient;\n"
1401 "uniform myhalf3 DeferredColor_Diffuse;\n"
1402 "#ifdef USESPECULAR\n"
1403 "uniform myhalf3 DeferredColor_Specular;\n"
1404 "uniform myhalf SpecularPower;\n"
1405 "#endif\n"
1406 "uniform myhalf2 PixelToScreenTexCoord;\n"
1407 "void main(void)\n"
1408 "{\n"
1409 "       // calculate viewspace pixel position\n"
1410 "       vec2 ScreenTexCoord = gl_FragCoord.xy * PixelToScreenTexCoord;\n"
1411 "       vec3 position;\n"
1412 "       position.z = ScreenToDepth.y / (texture2D(Texture_ScreenDepth, ScreenTexCoord).r + ScreenToDepth.x);\n"
1413 "       position.xy = ModelViewPosition.xy * (position.z / ModelViewPosition.z);\n"
1414 "       // decode viewspace pixel normal\n"
1415 "       myhalf4 normalmap = texture2D(Texture_ScreenNormalMap, ScreenTexCoord);\n"
1416 "       myhalf3 surfacenormal = normalize(normalmap.rgb - myhalf3(0.5,0.5,0.5));\n"
1417 "       // surfacenormal = pixel normal in viewspace\n"
1418 "       // LightVector = pixel to light in viewspace\n"
1419 "       // CubeVector = position in lightspace\n"
1420 "       // eyevector = pixel to view in viewspace\n"
1421 "       vec3 CubeVector = vec3(ViewToLight * vec4(position,1));\n"
1422 "       myhalf fade = myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n"
1423 "#ifdef USEDIFFUSE\n"
1424 "       // calculate diffuse shading\n"
1425 "       myhalf3 lightnormal = myhalf3(normalize(LightPosition - position));\n"
1426 "       myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
1427 "#endif\n"
1428 "#ifdef USESPECULAR\n"
1429 "       // calculate directional shading\n"
1430 "       vec3 eyevector = position * -1.0;\n"
1431 "#  ifdef USEEXACTSPECULARMATH\n"
1432 "       myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(eyevector)))*-1.0, 0.0)), SpecularPower * normalmap.a);\n"
1433 "#  else\n"
1434 "       myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(eyevector)));\n"
1435 "       myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * normalmap.a);\n"
1436 "#  endif\n"
1437 "#endif\n"
1438 "\n"
1439 "#if defined(USESHADOWMAP2D)\n"
1440 "       fade *= ShadowMapCompare(CubeVector);\n"
1441 "#endif\n"
1442 "\n"
1443 "#ifdef USEDIFFUSE\n"
1444 "       gl_FragData[0] = vec4((DeferredColor_Ambient + DeferredColor_Diffuse * diffuse) * fade, 1.0);\n"
1445 "#else\n"
1446 "       gl_FragData[0] = vec4(DeferredColor_Ambient * fade, 1.0);\n"
1447 "#endif\n"
1448 "#ifdef USESPECULAR\n"
1449 "       gl_FragData[1] = vec4(DeferredColor_Specular * (specular * fade), 1.0);\n"
1450 "#else\n"
1451 "       gl_FragData[1] = vec4(0.0, 0.0, 0.0, 1.0);\n"
1452 "#endif\n"
1453 "\n"
1454 "# ifdef USECUBEFILTER\n"
1455 "       vec3 cubecolor = textureCube(Texture_Cube, CubeVector).rgb;\n"
1456 "       gl_FragData[0].rgb *= cubecolor;\n"
1457 "       gl_FragData[1].rgb *= cubecolor;\n"
1458 "# endif\n"
1459 "}\n"
1460 "#endif // FRAGMENT_SHADER\n"
1461 "#else // !MODE_DEFERREDLIGHTSOURCE\n"
1462 "\n"
1463 "\n"
1464 "\n"
1465 "\n"
1466 "#ifdef VERTEX_SHADER\n"
1467 "uniform mat4 TexMatrix;\n"
1468 "#ifdef USEVERTEXTEXTUREBLEND\n"
1469 "uniform mat4 BackgroundTexMatrix;\n"
1470 "#endif\n"
1471 "#ifdef MODE_LIGHTSOURCE\n"
1472 "uniform mat4 ModelToLight;\n"
1473 "#endif\n"
1474 "#ifdef USESHADOWMAPORTHO\n"
1475 "uniform mat4 ShadowMapMatrix;\n"
1476 "#endif\n"
1477 "void main(void)\n"
1478 "{\n"
1479 "#if defined(MODE_VERTEXCOLOR) || defined(USEVERTEXTEXTUREBLEND)\n"
1480 "       gl_FrontColor = gl_Color;\n"
1481 "#endif\n"
1482 "       // copy the surface texcoord\n"
1483 "       TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
1484 "#ifdef USEVERTEXTEXTUREBLEND\n"
1485 "       TexCoord2 = vec2(BackgroundTexMatrix * gl_MultiTexCoord0);\n"
1486 "#endif\n"
1487 "#ifdef USELIGHTMAP\n"
1488 "       TexCoordLightmap = vec2(gl_MultiTexCoord4);\n"
1489 "#endif\n"
1490 "\n"
1491 "#ifdef MODE_LIGHTSOURCE\n"
1492 "       // transform vertex position into light attenuation/cubemap space\n"
1493 "       // (-1 to +1 across the light box)\n"
1494 "       CubeVector = vec3(ModelToLight * gl_Vertex);\n"
1495 "\n"
1496 "# ifdef USEDIFFUSE\n"
1497 "       // transform unnormalized light direction into tangent space\n"
1498 "       // (we use unnormalized to ensure that it interpolates correctly and then\n"
1499 "       //  normalize it per pixel)\n"
1500 "       vec3 lightminusvertex = LightPosition - gl_Vertex.xyz;\n"
1501 "       LightVector.x = dot(lightminusvertex, gl_MultiTexCoord1.xyz);\n"
1502 "       LightVector.y = dot(lightminusvertex, gl_MultiTexCoord2.xyz);\n"
1503 "       LightVector.z = dot(lightminusvertex, gl_MultiTexCoord3.xyz);\n"
1504 "# endif\n"
1505 "#endif\n"
1506 "\n"
1507 "#if defined(MODE_LIGHTDIRECTION) && defined(USEDIFFUSE)\n"
1508 "       LightVector.x = dot(LightDir, gl_MultiTexCoord1.xyz);\n"
1509 "       LightVector.y = dot(LightDir, gl_MultiTexCoord2.xyz);\n"
1510 "       LightVector.z = dot(LightDir, gl_MultiTexCoord3.xyz);\n"
1511 "#endif\n"
1512 "\n"
1513 "       // transform unnormalized eye direction into tangent space\n"
1514 "#ifdef USEEYEVECTOR\n"
1515 "       vec3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
1516 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
1517 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
1518 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
1519 "#endif\n"
1520 "\n"
1521 "#ifdef USEFOG\n"
1522 "       EyeVectorModelSpaceFogPlaneVertexDist.xyz = EyePosition - gl_Vertex.xyz;\n"
1523 "       EyeVectorModelSpaceFogPlaneVertexDist.w = dot(FogPlane, gl_Vertex);\n"
1524 "#endif\n"
1525 "\n"
1526 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(USEREFLECTCUBE)\n"
1527 "       VectorS = gl_MultiTexCoord1.xyz;\n"
1528 "       VectorT = gl_MultiTexCoord2.xyz;\n"
1529 "       VectorR = gl_MultiTexCoord3.xyz;\n"
1530 "#endif\n"
1531 "\n"
1532 "       // transform vertex to camera space, using ftransform to match non-VS rendering\n"
1533 "       gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
1534 "\n"
1535 "#ifdef USESHADOWMAPORTHO\n"
1536 "       ShadowMapTC = vec3(ShadowMapMatrix * gl_Position);\n"
1537 "#endif\n"
1538 "\n"
1539 "#ifdef USEREFLECTION\n"
1540 "       ModelViewProjectionPosition = gl_Position;\n"
1541 "#endif\n"
1542 "}\n"
1543 "#endif // VERTEX_SHADER\n"
1544 "\n"
1545 "\n"
1546 "\n"
1547 "\n"
1548 "#ifdef FRAGMENT_SHADER\n"
1549 "#ifdef USEDEFERREDLIGHTMAP\n"
1550 "uniform myhalf2 PixelToScreenTexCoord;\n"
1551 "uniform myhalf3 DeferredMod_Diffuse;\n"
1552 "uniform myhalf3 DeferredMod_Specular;\n"
1553 "#endif\n"
1554 "uniform myhalf3 Color_Ambient;\n"
1555 "uniform myhalf3 Color_Diffuse;\n"
1556 "uniform myhalf3 Color_Specular;\n"
1557 "uniform myhalf SpecularPower;\n"
1558 "#ifdef USEGLOW\n"
1559 "uniform myhalf3 Color_Glow;\n"
1560 "#endif\n"
1561 "uniform myhalf Alpha;\n"
1562 "#ifdef USEREFLECTION\n"
1563 "uniform vec4 DistortScaleRefractReflect;\n"
1564 "uniform vec4 ScreenScaleRefractReflect;\n"
1565 "uniform vec4 ScreenCenterRefractReflect;\n"
1566 "uniform myhalf4 ReflectColor;\n"
1567 "#endif\n"
1568 "#ifdef USEREFLECTCUBE\n"
1569 "uniform mat4 ModelToReflectCube;\n"
1570 "uniform sampler2D Texture_ReflectMask;\n"
1571 "uniform samplerCube Texture_ReflectCube;\n"
1572 "#endif\n"
1573 "#ifdef MODE_LIGHTDIRECTION\n"
1574 "uniform myhalf3 LightColor;\n"
1575 "#endif\n"
1576 "#ifdef MODE_LIGHTSOURCE\n"
1577 "uniform myhalf3 LightColor;\n"
1578 "#endif\n"
1579 "void main(void)\n"
1580 "{\n"
1581 "#ifdef USEOFFSETMAPPING\n"
1582 "       // apply offsetmapping\n"
1583 "       vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
1584 "#define TexCoord TexCoordOffset\n"
1585 "#endif\n"
1586 "\n"
1587 "       // combine the diffuse textures (base, pants, shirt)\n"
1588 "       myhalf4 color = myhalf4(texture2D(Texture_Color, TexCoord));\n"
1589 "#ifdef USEALPHAKILL\n"
1590 "       if (color.a < 0.5)\n"
1591 "               discard;\n"
1592 "#endif\n"
1593 "       color.a *= Alpha;\n"
1594 "#ifdef USECOLORMAPPING\n"
1595 "       color.rgb += myhalf3(texture2D(Texture_Pants, TexCoord)) * Color_Pants + myhalf3(texture2D(Texture_Shirt, TexCoord)) * Color_Shirt;\n"
1596 "#endif\n"
1597 "#ifdef USEVERTEXTEXTUREBLEND\n"
1598 "       myhalf terrainblend = clamp(myhalf(gl_Color.a) * color.a * 2.0 - 0.5, myhalf(0.0), myhalf(1.0));\n"
1599 "       //myhalf terrainblend = min(myhalf(gl_Color.a) * color.a * 2.0, myhalf(1.0));\n"
1600 "       //myhalf terrainblend = myhalf(gl_Color.a) * color.a > 0.5;\n"
1601 "       color.rgb = mix(myhalf3(texture2D(Texture_SecondaryColor, TexCoord2)), color.rgb, terrainblend);\n"
1602 "       color.a = 1.0;\n"
1603 "       //color = mix(myhalf4(1, 0, 0, 1), color, terrainblend);\n"
1604 "#endif\n"
1605 "\n"
1606 "       // get the surface normal\n"
1607 "#ifdef USEVERTEXTEXTUREBLEND\n"
1608 "       myhalf3 surfacenormal = normalize(mix(myhalf3(texture2D(Texture_SecondaryNormal, TexCoord2)), myhalf3(texture2D(Texture_Normal, TexCoord)), terrainblend) - myhalf3(0.5, 0.5, 0.5));\n"
1609 "#else\n"
1610 "       myhalf3 surfacenormal = normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5, 0.5, 0.5));\n"
1611 "#endif\n"
1612 "\n"
1613 "       // get the material colors\n"
1614 "       myhalf3 diffusetex = color.rgb;\n"
1615 "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
1616 "# ifdef USEVERTEXTEXTUREBLEND\n"
1617 "       myhalf4 glosstex = mix(myhalf4(texture2D(Texture_SecondaryGloss, TexCoord2)), myhalf4(texture2D(Texture_Gloss, TexCoord)), terrainblend);\n"
1618 "# else\n"
1619 "       myhalf4 glosstex = myhalf4(texture2D(Texture_Gloss, TexCoord));\n"
1620 "# endif\n"
1621 "#endif\n"
1622 "\n"
1623 "#ifdef USEREFLECTCUBE\n"
1624 "       vec3 TangentReflectVector = reflect(-EyeVector, surfacenormal);\n"
1625 "       vec3 ModelReflectVector = TangentReflectVector.x * VectorS + TangentReflectVector.y * VectorT + TangentReflectVector.z * VectorR;\n"
1626 "       vec3 ReflectCubeTexCoord = vec3(ModelToReflectCube * vec4(ModelReflectVector, 0));\n"
1627 "       diffusetex += myhalf3(texture2D(Texture_ReflectMask, TexCoord)) * myhalf3(textureCube(Texture_ReflectCube, ReflectCubeTexCoord));\n"
1628 "#endif\n"
1629 "\n"
1630 "\n"
1631 "\n"
1632 "\n"
1633 "#ifdef MODE_LIGHTSOURCE\n"
1634 "       // light source\n"
1635 "#ifdef USEDIFFUSE\n"
1636 "       myhalf3 lightnormal = myhalf3(normalize(LightVector));\n"
1637 "       myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
1638 "       color.rgb = diffusetex * (Color_Ambient + diffuse * Color_Diffuse);\n"
1639 "#ifdef USESPECULAR\n"
1640 "#ifdef USEEXACTSPECULARMATH\n"
1641 "       myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a);\n"
1642 "#else\n"
1643 "       myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(EyeVector)));\n"
1644 "       myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a);\n"
1645 "#endif\n"
1646 "       color.rgb += glosstex.rgb * (specular * Color_Specular);\n"
1647 "#endif\n"
1648 "#else\n"
1649 "       color.rgb = diffusetex * Color_Ambient;\n"
1650 "#endif\n"
1651 "       color.rgb *= LightColor;\n"
1652 "       color.rgb *= myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n"
1653 "#if defined(USESHADOWMAP2D)\n"
1654 "       color.rgb *= ShadowMapCompare(CubeVector);\n"
1655 "#endif\n"
1656 "# ifdef USECUBEFILTER\n"
1657 "       color.rgb *= myhalf3(textureCube(Texture_Cube, CubeVector));\n"
1658 "# endif\n"
1659 "#endif // MODE_LIGHTSOURCE\n"
1660 "\n"
1661 "\n"
1662 "\n"
1663 "\n"
1664 "#ifdef MODE_LIGHTDIRECTION\n"
1665 "#define SHADING\n"
1666 "#ifdef USEDIFFUSE\n"
1667 "       myhalf3 lightnormal = myhalf3(normalize(LightVector));\n"
1668 "#endif\n"
1669 "#define lightcolor LightColor\n"
1670 "#endif // MODE_LIGHTDIRECTION\n"
1671 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
1672 "#define SHADING\n"
1673 "       // deluxemap lightmapping using light vectors in modelspace (q3map2 -light -deluxe)\n"
1674 "       myhalf3 lightnormal_modelspace = myhalf3(texture2D(Texture_Deluxemap, TexCoordLightmap)) * 2.0 + myhalf3(-1.0, -1.0, -1.0);\n"
1675 "       myhalf3 lightcolor = myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap));\n"
1676 "       // convert modelspace light vector to tangentspace\n"
1677 "       myhalf3 lightnormal;\n"
1678 "       lightnormal.x = dot(lightnormal_modelspace, myhalf3(VectorS));\n"
1679 "       lightnormal.y = dot(lightnormal_modelspace, myhalf3(VectorT));\n"
1680 "       lightnormal.z = dot(lightnormal_modelspace, myhalf3(VectorR));\n"
1681 "       lightnormal = normalize(lightnormal); // VectorS/T/R are not always perfectly normalized, and EXACTSPECULARMATH is very picky about this\n"
1682 "       // calculate directional shading (and undoing the existing angle attenuation on the lightmap by the division)\n"
1683 "       // note that q3map2 is too stupid to calculate proper surface normals when q3map_nonplanar\n"
1684 "       // is used (the lightmap and deluxemap coords correspond to virtually random coordinates\n"
1685 "       // on that luxel, and NOT to its center, because recursive triangle subdivision is used\n"
1686 "       // to map the luxels to coordinates on the draw surfaces), which also causes\n"
1687 "       // deluxemaps to be wrong because light contributions from the wrong side of the surface\n"
1688 "       // are added up. To prevent divisions by zero or strong exaggerations, a max()\n"
1689 "       // nudge is done here at expense of some additional fps. This is ONLY needed for\n"
1690 "       // deluxemaps, tangentspace deluxemap avoid this problem by design.\n"
1691 "       lightcolor *= 1.0 / max(0.25, lightnormal.z);\n"
1692 "#endif // MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
1693 "#ifdef MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
1694 "#define SHADING\n"
1695 "       // deluxemap lightmapping using light vectors in tangentspace (hmap2 -light)\n"
1696 "       myhalf3 lightnormal = myhalf3(texture2D(Texture_Deluxemap, TexCoordLightmap)) * 2.0 + myhalf3(-1.0, -1.0, -1.0);\n"
1697 "       myhalf3 lightcolor = myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap));\n"
1698 "#endif\n"
1699 "\n"
1700 "\n"
1701 "\n"
1702 "\n"
1703 "#ifdef MODE_FAKELIGHT\n"
1704 "#define SHADING\n"
1705 "myhalf3 lightnormal = myhalf3(normalize(EyeVector));\n"
1706 "myhalf3 lightcolor = myhalf3(1.0);\n"
1707 "#endif // MODE_FAKELIGHT\n"
1708 "\n"
1709 "\n"
1710 "\n"
1711 "\n"
1712 "#ifdef MODE_LIGHTMAP\n"
1713 "       color.rgb = diffusetex * (Color_Ambient + myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap)) * Color_Diffuse);\n"
1714 "#endif // MODE_LIGHTMAP\n"
1715 "#ifdef MODE_VERTEXCOLOR\n"
1716 "       color.rgb = diffusetex * (Color_Ambient + myhalf3(gl_Color.rgb) * Color_Diffuse);\n"
1717 "#endif // MODE_VERTEXCOLOR\n"
1718 "#ifdef MODE_FLATCOLOR\n"
1719 "       color.rgb = diffusetex * Color_Ambient;\n"
1720 "#endif // MODE_FLATCOLOR\n"
1721 "\n"
1722 "\n"
1723 "\n"
1724 "\n"
1725 "#ifdef SHADING\n"
1726 "# ifdef USEDIFFUSE\n"
1727 "       myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
1728 "#  ifdef USESPECULAR\n"
1729 "#   ifdef USEEXACTSPECULARMATH\n"
1730 "       myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a);\n"
1731 "#   else\n"
1732 "       myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(EyeVector)));\n"
1733 "       myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a);\n"
1734 "#   endif\n"
1735 "       color.rgb = diffusetex * Color_Ambient + (diffusetex * Color_Diffuse * diffuse + glosstex.rgb * Color_Specular * specular) * lightcolor;\n"
1736 "#  else\n"
1737 "       color.rgb = diffusetex * (Color_Ambient + Color_Diffuse * diffuse * lightcolor);\n"
1738 "#  endif\n"
1739 "# else\n"
1740 "       color.rgb = diffusetex * Color_Ambient;\n"
1741 "# endif\n"
1742 "#endif\n"
1743 "\n"
1744 "#ifdef USESHADOWMAPORTHO\n"
1745 "       color.rgb *= ShadowMapCompare(ShadowMapTC);\n"
1746 "#endif\n"
1747 "\n"
1748 "#ifdef USEDEFERREDLIGHTMAP\n"
1749 "       vec2 ScreenTexCoord = gl_FragCoord.xy * PixelToScreenTexCoord;\n"
1750 "       color.rgb += diffusetex * myhalf3(texture2D(Texture_ScreenDiffuse, ScreenTexCoord)) * DeferredMod_Diffuse;\n"
1751 "       color.rgb += glosstex.rgb * myhalf3(texture2D(Texture_ScreenSpecular, ScreenTexCoord)) * DeferredMod_Specular;\n"
1752 "#endif\n"
1753 "\n"
1754 "#ifdef USEGLOW\n"
1755 "#ifdef USEVERTEXTEXTUREBLEND\n"
1756 "       color.rgb += mix(myhalf3(texture2D(Texture_SecondaryGlow, TexCoord2)), myhalf3(texture2D(Texture_Glow, TexCoord)), terrainblend) * Color_Glow;\n"
1757 "#else\n"
1758 "       color.rgb += myhalf3(texture2D(Texture_Glow, TexCoord)) * Color_Glow;\n"
1759 "#endif\n"
1760 "#endif\n"
1761 "\n"
1762 "#ifdef USEFOG\n"
1763 "       color.rgb = FogVertex(color.rgb);\n"
1764 "#endif\n"
1765 "\n"
1766 "       // 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"
1767 "#ifdef USEREFLECTION\n"
1768 "       vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
1769 "       //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
1770 "       vec2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW.zw + ScreenCenterRefractReflect.zw;\n"
1771 "       vec2 ScreenTexCoord = SafeScreenTexCoord + vec3(normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5))).xy * DistortScaleRefractReflect.zw;\n"
1772 "       // FIXME temporary hack to detect the case that the reflection\n"
1773 "       // gets blackened at edges due to leaving the area that contains actual\n"
1774 "       // content.\n"
1775 "       // Remove this 'ack once we have a better way to stop this thing from\n"
1776 "       // 'appening.\n"
1777 "       float f = min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(0.01, 0.01)).rgb) / 0.05);\n"
1778 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(0.01, -0.01)).rgb) / 0.05);\n"
1779 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
1780 "       f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
1781 "       ScreenTexCoord = mix(SafeScreenTexCoord, ScreenTexCoord, f);\n"
1782 "       color.rgb = mix(color.rgb, myhalf3(texture2D(Texture_Reflection, ScreenTexCoord)) * ReflectColor.rgb, ReflectColor.a);\n"
1783 "#endif\n"
1784 "\n"
1785 "       gl_FragColor = vec4(color);\n"
1786 "}\n"
1787 "#endif // FRAGMENT_SHADER\n"
1788 "\n"
1789 "#endif // !MODE_DEFERREDLIGHTSOURCE\n"
1790 "#endif // !MODE_DEFERREDGEOMETRY\n"
1791 "#endif // !MODE_WATER\n"
1792 "#endif // !MODE_REFRACTION\n"
1793 "#endif // !MODE_BLOOMBLUR\n"
1794 "#endif // !MODE_GENERIC\n"
1795 "#endif // !MODE_POSTPROCESS\n"
1796 "#endif // !MODE_SHOWDEPTH\n"
1797 "#endif // !MODE_DEPTH_OR_SHADOW\n"
1798 ;
1799
1800 /*
1801 =========================================================================================================================================================
1802
1803
1804
1805 =========================================================================================================================================================
1806
1807
1808
1809 =========================================================================================================================================================
1810
1811
1812
1813 =========================================================================================================================================================
1814
1815
1816
1817 =========================================================================================================================================================
1818
1819
1820
1821 =========================================================================================================================================================
1822
1823
1824
1825 =========================================================================================================================================================
1826 */
1827
1828 const char *builtincgshaderstring =
1829 "// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
1830 "// written by Forest 'LordHavoc' Hale\n"
1831 "// shadowmapping enhancements by Lee 'eihrul' Salzman\n"
1832 "\n"
1833 "// FIXME: we need to get rid of ModelViewProjectionPosition to make room for the texcoord for this\n"
1834 "#if defined(USEREFLECTION)\n"
1835 "#undef USESHADOWMAPORTHO\n"
1836 "#endif\n"
1837 "\n"
1838 "#if defined(USEFOGINSIDE) || defined(USEFOGOUTSIDE) || defined(USEFOGHEIGHTTEXTURE)\n"
1839 "# define USEFOG\n"
1840 "#endif\n"
1841 "#if defined(MODE_LIGHTMAP) || defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
1842 "#define USELIGHTMAP\n"
1843 "#endif\n"
1844 "#if defined(USESPECULAR) || defined(USEOFFSETMAPPING) || defined(USEREFLECTCUBE) || defined(MODE_FAKELIGHT)\n"
1845 "#define USEEYEVECTOR\n"
1846 "#endif\n"
1847 "\n"
1848 "#ifdef FRAGMENT_SHADER\n"
1849 "#ifdef HLSL\n"
1850 "//#undef USESHADOWMAPPCF\n"
1851 "//#define texDepth2D(tex,texcoord) tex2D(tex,texcoord).r\n"
1852 "#define texDepth2D(tex,texcoord) dot(tex2D(tex,texcoord).rgb, float3(1.0, 255.0/65536.0, 255.0/16777216.0))\n"
1853 "#else\n"
1854 "#define texDepth2D(tex,texcoord) tex2D(tex,texcoord).r\n"
1855 "#endif\n"
1856 "#endif\n"
1857 "\n"
1858 "#ifdef MODE_DEPTH_OR_SHADOW\n"
1859 "#ifdef VERTEX_SHADER\n"
1860 "void main\n"
1861 "(\n"
1862 "float4 gl_Vertex : POSITION,\n"
1863 "uniform float4x4 ModelViewProjectionMatrix : register(c8),\n"
1864 "out float4 gl_Position : POSITION,\n"
1865 "out float Depth : TEXCOORD0\n"
1866 ")\n"
1867 "{\n"
1868 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
1869 "       Depth = gl_Position.z;\n"
1870 "}\n"
1871 "#endif\n"
1872 "\n"
1873 "#ifdef FRAGMENT_SHADER\n"
1874 "void main\n"
1875 "(\n"
1876 "float Depth : TEXCOORD0,\n"
1877 "out float4 gl_FragColor : COLOR\n"
1878 ")\n"
1879 "{\n"
1880 "//     float4 temp = float4(Depth,Depth*(65536.0/255.0),Depth*(16777216.0/255.0),0.0);\n"
1881 "       float4 temp = float4(Depth,Depth*256.0,Depth*65536.0,0.0);\n"
1882 "       temp.yz -= floor(temp.yz);\n"
1883 "       gl_FragColor = temp;\n"
1884 "//     gl_FragColor = float4(Depth,0,0,0);\n"
1885 "}\n"
1886 "#endif\n"
1887 "#else // !MODE_DEPTH_ORSHADOW\n"
1888 "\n"
1889 "\n"
1890 "\n"
1891 "\n"
1892 "#ifdef MODE_SHOWDEPTH\n"
1893 "#ifdef VERTEX_SHADER\n"
1894 "void main\n"
1895 "(\n"
1896 "float4 gl_Vertex : POSITION,\n"
1897 "uniform float4x4 ModelViewProjectionMatrix : register(c8),\n"
1898 "out float4 gl_Position : POSITION,\n"
1899 "out float4 gl_FrontColor : COLOR0\n"
1900 ")\n"
1901 "{\n"
1902 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
1903 "       gl_FrontColor = float4(gl_Position.z, gl_Position.z, gl_Position.z, 1.0);\n"
1904 "}\n"
1905 "#endif\n"
1906 "\n"
1907 "#ifdef FRAGMENT_SHADER\n"
1908 "void main\n"
1909 "(\n"
1910 "float4 gl_FrontColor : COLOR0,\n"
1911 "out float4 gl_FragColor : COLOR\n"
1912 ")\n"
1913 "{\n"
1914 "       gl_FragColor = gl_FrontColor;\n"
1915 "}\n"
1916 "#endif\n"
1917 "#else // !MODE_SHOWDEPTH\n"
1918 "\n"
1919 "\n"
1920 "\n"
1921 "\n"
1922 "#ifdef MODE_POSTPROCESS\n"
1923 "\n"
1924 "#ifdef VERTEX_SHADER\n"
1925 "void main\n"
1926 "(\n"
1927 "float4 gl_Vertex : POSITION,\n"
1928 "uniform float4x4 ModelViewProjectionMatrix : register(c8),\n"
1929 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
1930 "float4 gl_MultiTexCoord4 : TEXCOORD4,\n"
1931 "out float4 gl_Position : POSITION,\n"
1932 "out float2 TexCoord1 : TEXCOORD0,\n"
1933 "out float2 TexCoord2 : TEXCOORD1\n"
1934 ")\n"
1935 "{\n"
1936 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
1937 "       TexCoord1 = gl_MultiTexCoord0.xy;\n"
1938 "#ifdef USEBLOOM\n"
1939 "       TexCoord2 = gl_MultiTexCoord4.xy;\n"
1940 "#endif\n"
1941 "}\n"
1942 "#endif\n"
1943 "\n"
1944 "#ifdef FRAGMENT_SHADER\n"
1945 "void main\n"
1946 "(\n"
1947 "float2 TexCoord1 : TEXCOORD0,\n"
1948 "float2 TexCoord2 : TEXCOORD1,\n"
1949 "uniform sampler Texture_First : register(s0),\n"
1950 "#ifdef USEBLOOM\n"
1951 "uniform sampler Texture_Second : register(s1),\n"
1952 "#endif\n"
1953 "#ifdef USEGAMMARAMPS\n"
1954 "uniform sampler Texture_GammaRamps : register(s2),\n"
1955 "#endif\n"
1956 "#ifdef USESATURATION\n"
1957 "uniform float Saturation : register(c30),\n"
1958 "#endif\n"
1959 "#ifdef USEVIEWTINT\n"
1960 "uniform float4 ViewTintColor : register(c41),\n"
1961 "#endif\n"
1962 "uniform float4 UserVec1 : register(c37),\n"
1963 "uniform float4 UserVec2 : register(c38),\n"
1964 "uniform float4 UserVec3 : register(c39),\n"
1965 "uniform float4 UserVec4 : register(c40),\n"
1966 "uniform float ClientTime : register(c2),\n"
1967 "uniform float2 PixelSize : register(c25),\n"
1968 "uniform float4 BloomColorSubtract : register(c43),\n"
1969 "out float4 gl_FragColor : COLOR\n"
1970 ")\n"
1971 "{\n"
1972 "       gl_FragColor = tex2D(Texture_First, TexCoord1);\n"
1973 "#ifdef USEBLOOM\n"
1974 "       gl_FragColor += max(float4(0,0,0,0), tex2D(Texture_Second, TexCoord2) - BloomColorSubtract);\n"
1975 "#endif\n"
1976 "#ifdef USEVIEWTINT\n"
1977 "       gl_FragColor = lerp(gl_FragColor, ViewTintColor, ViewTintColor.a);\n"
1978 "#endif\n"
1979 "\n"
1980 "#ifdef USEPOSTPROCESSING\n"
1981 "// do r_glsl_dumpshader, edit glsl/default.glsl, and replace this by your own postprocessing if you want\n"
1982 "// 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"
1983 "       float sobel = 1.0;\n"
1984 "       // float2 ts = textureSize(Texture_First, 0);\n"
1985 "       // float2 px = float2(1/ts.x, 1/ts.y);\n"
1986 "       float2 px = PixelSize;\n"
1987 "       float3 x1 = tex2D(Texture_First, TexCoord1 + float2(-px.x, px.y)).rgb;\n"
1988 "       float3 x2 = tex2D(Texture_First, TexCoord1 + float2(-px.x,  0.0)).rgb;\n"
1989 "       float3 x3 = tex2D(Texture_First, TexCoord1 + float2(-px.x,-px.y)).rgb;\n"
1990 "       float3 x4 = tex2D(Texture_First, TexCoord1 + float2( px.x, px.y)).rgb;\n"
1991 "       float3 x5 = tex2D(Texture_First, TexCoord1 + float2( px.x,  0.0)).rgb;\n"
1992 "       float3 x6 = tex2D(Texture_First, TexCoord1 + float2( px.x,-px.y)).rgb;\n"
1993 "       float3 y1 = tex2D(Texture_First, TexCoord1 + float2( px.x,-px.y)).rgb;\n"
1994 "       float3 y2 = tex2D(Texture_First, TexCoord1 + float2(  0.0,-px.y)).rgb;\n"
1995 "       float3 y3 = tex2D(Texture_First, TexCoord1 + float2(-px.x,-px.y)).rgb;\n"
1996 "       float3 y4 = tex2D(Texture_First, TexCoord1 + float2( px.x, px.y)).rgb;\n"
1997 "       float3 y5 = tex2D(Texture_First, TexCoord1 + float2(  0.0, px.y)).rgb;\n"
1998 "       float3 y6 = tex2D(Texture_First, TexCoord1 + float2(-px.x, px.y)).rgb;\n"
1999 "       float px1 = -1.0 * dot(float3(0.3, 0.59, 0.11), x1);\n"
2000 "       float px2 = -2.0 * dot(float3(0.3, 0.59, 0.11), x2);\n"
2001 "       float px3 = -1.0 * dot(float3(0.3, 0.59, 0.11), x3);\n"
2002 "       float px4 =  1.0 * dot(float3(0.3, 0.59, 0.11), x4);\n"
2003 "       float px5 =  2.0 * dot(float3(0.3, 0.59, 0.11), x5);\n"
2004 "       float px6 =  1.0 * dot(float3(0.3, 0.59, 0.11), x6);\n"
2005 "       float py1 = -1.0 * dot(float3(0.3, 0.59, 0.11), y1);\n"
2006 "       float py2 = -2.0 * dot(float3(0.3, 0.59, 0.11), y2);\n"
2007 "       float py3 = -1.0 * dot(float3(0.3, 0.59, 0.11), y3);\n"
2008 "       float py4 =  1.0 * dot(float3(0.3, 0.59, 0.11), y4);\n"
2009 "       float py5 =  2.0 * dot(float3(0.3, 0.59, 0.11), y5);\n"
2010 "       float py6 =  1.0 * dot(float3(0.3, 0.59, 0.11), y6);\n"
2011 "       sobel = 0.25 * abs(px1 + px2 + px3 + px4 + px5 + px6) + 0.25 * abs(py1 + py2 + py3 + py4 + py5 + py6);\n"
2012 "       gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2(-0.987688, -0.156434)) * UserVec1.y;\n"
2013 "       gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2(-0.156434, -0.891007)) * UserVec1.y;\n"
2014 "       gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2( 0.891007, -0.453990)) * UserVec1.y;\n"
2015 "       gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2( 0.707107,  0.707107)) * UserVec1.y;\n"
2016 "       gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2(-0.453990,  0.891007)) * UserVec1.y;\n"
2017 "       gl_FragColor /= (1.0 + 5.0 * UserVec1.y);\n"
2018 "       gl_FragColor.rgb = gl_FragColor.rgb * (1.0 + UserVec2.x) + float3(1,1,1)*max(0.0, sobel - UserVec2.z)*UserVec2.y;\n"
2019 "#endif\n"
2020 "\n"
2021 "#ifdef USESATURATION\n"
2022 "       //apply saturation BEFORE gamma ramps, so v_glslgamma value does not matter\n"
2023 "       float y = dot(gl_FragColor.rgb, float3(0.299, 0.587, 0.114));\n"
2024 "       // 'vampire sight' effect, wheres red is compensated\n"
2025 "       #ifdef SATURATION_REDCOMPENSATE\n"
2026 "               float rboost = max(0.0, (gl_FragColor.r - max(gl_FragColor.g, gl_FragColor.b))*(1.0 - Saturation));\n"
2027 "               gl_FragColor.rgb = mix(float3(y,y,y), gl_FragColor.rgb, Saturation);\n"
2028 "               gl_FragColor.r += r;\n"
2029 "       #else\n"
2030 "               // normal desaturation\n"
2031 "               //gl_FragColor = float3(y,y,y) + (gl_FragColor.rgb - float3(y)) * Saturation;\n"
2032 "               gl_FragColor.rgb = lerp(float3(y,y,y), gl_FragColor.rgb, Saturation);\n"
2033 "       #endif\n"
2034 "#endif\n"
2035 "\n"
2036 "#ifdef USEGAMMARAMPS\n"
2037 "       gl_FragColor.r = tex2D(Texture_GammaRamps, float2(gl_FragColor.r, 0)).r;\n"
2038 "       gl_FragColor.g = tex2D(Texture_GammaRamps, float2(gl_FragColor.g, 0)).g;\n"
2039 "       gl_FragColor.b = tex2D(Texture_GammaRamps, float2(gl_FragColor.b, 0)).b;\n"
2040 "#endif\n"
2041 "}\n"
2042 "#endif\n"
2043 "#else // !MODE_POSTPROCESS\n"
2044 "\n"
2045 "\n"
2046 "\n"
2047 "\n"
2048 "#ifdef MODE_GENERIC\n"
2049 "#ifdef VERTEX_SHADER\n"
2050 "void main\n"
2051 "(\n"
2052 "float4 gl_Vertex : POSITION,\n"
2053 "uniform float4x4 ModelViewProjectionMatrix : register(c8),\n"
2054 "float4 gl_Color : COLOR0,\n"
2055 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2056 "float4 gl_MultiTexCoord1 : TEXCOORD1,\n"
2057 "out float4 gl_Position : POSITION,\n"
2058 "#ifdef USEDIFFUSE\n"
2059 "out float2 TexCoord1 : TEXCOORD0,\n"
2060 "#endif\n"
2061 "#ifdef USESPECULAR\n"
2062 "out float2 TexCoord2 : TEXCOORD1,\n"
2063 "#endif\n"
2064 "out float4 gl_FrontColor : COLOR\n"
2065 ")\n"
2066 "{\n"
2067 "#ifdef HLSL\n"
2068 "       gl_FrontColor = gl_Color.bgra; // NOTE: D3DCOLOR is backwards\n"
2069 "#else\n"
2070 "       gl_FrontColor = gl_Color; // Cg is forward\n"
2071 "#endif\n"
2072 "#ifdef USEDIFFUSE\n"
2073 "       TexCoord1 = gl_MultiTexCoord0.xy;\n"
2074 "#endif\n"
2075 "#ifdef USESPECULAR\n"
2076 "       TexCoord2 = gl_MultiTexCoord1.xy;\n"
2077 "#endif\n"
2078 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2079 "}\n"
2080 "#endif\n"
2081 "\n"
2082 "#ifdef FRAGMENT_SHADER\n"
2083 "\n"
2084 "void main\n"
2085 "(\n"
2086 "float4 gl_FrontColor : COLOR0,\n"
2087 "float2 TexCoord1 : TEXCOORD0,\n"
2088 "float2 TexCoord2 : TEXCOORD1,\n"
2089 "#ifdef USEDIFFUSE\n"
2090 "uniform sampler Texture_First : register(s0),\n"
2091 "#endif\n"
2092 "#ifdef USESPECULAR\n"
2093 "uniform sampler Texture_Second : register(s1),\n"
2094 "#endif\n"
2095 "out float4 gl_FragColor : COLOR\n"
2096 ")\n"
2097 "{\n"
2098 "#ifdef USEVIEWTINT\n"
2099 "       gl_FragColor = gl_FrontColor;\n"
2100 "#else\n"
2101 "       gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);\n"
2102 "#endif\n"
2103 "#ifdef USEDIFFUSE\n"
2104 "       gl_FragColor *= tex2D(Texture_First, TexCoord1);\n"
2105 "#endif\n"
2106 "\n"
2107 "#ifdef USESPECULAR\n"
2108 "       float4 tex2 = tex2D(Texture_Second, TexCoord2);\n"
2109 "# ifdef USECOLORMAPPING\n"
2110 "       gl_FragColor *= tex2;\n"
2111 "# endif\n"
2112 "# ifdef USEGLOW\n"
2113 "       gl_FragColor += tex2;\n"
2114 "# endif\n"
2115 "# ifdef USEVERTEXTEXTUREBLEND\n"
2116 "       gl_FragColor = lerp(gl_FragColor, tex2, tex2.a);\n"
2117 "# endif\n"
2118 "#endif\n"
2119 "}\n"
2120 "#endif\n"
2121 "#else // !MODE_GENERIC\n"
2122 "\n"
2123 "\n"
2124 "\n"
2125 "\n"
2126 "#ifdef MODE_BLOOMBLUR\n"
2127 "#ifdef VERTEX_SHADER\n"
2128 "void main\n"
2129 "(\n"
2130 "float4 gl_Vertex : POSITION,\n"
2131 "uniform float4x4 ModelViewProjectionMatrix : register(c8),\n"
2132 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2133 "out float4 gl_Position : POSITION,\n"
2134 "out float2 TexCoord : TEXCOORD0\n"
2135 ")\n"
2136 "{\n"
2137 "       TexCoord = gl_MultiTexCoord0.xy;\n"
2138 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2139 "}\n"
2140 "#endif\n"
2141 "\n"
2142 "#ifdef FRAGMENT_SHADER\n"
2143 "\n"
2144 "void main\n"
2145 "(\n"
2146 "float2 TexCoord : TEXCOORD0,\n"
2147 "uniform sampler Texture_First : register(s0),\n"
2148 "uniform float4 BloomBlur_Parameters : register(c1),\n"
2149 "out float4 gl_FragColor : COLOR\n"
2150 ")\n"
2151 "{\n"
2152 "       int i;\n"
2153 "       float2 tc = TexCoord;\n"
2154 "       float3 color = tex2D(Texture_First, tc).rgb;\n"
2155 "       tc += BloomBlur_Parameters.xy;\n"
2156 "       for (i = 1;i < SAMPLES;i++)\n"
2157 "       {\n"
2158 "               color += tex2D(Texture_First, tc).rgb;\n"
2159 "               tc += BloomBlur_Parameters.xy;\n"
2160 "       }\n"
2161 "       gl_FragColor = float4(color * BloomBlur_Parameters.z + float3(BloomBlur_Parameters.w), 1);\n"
2162 "}\n"
2163 "#endif\n"
2164 "#else // !MODE_BLOOMBLUR\n"
2165 "#ifdef MODE_REFRACTION\n"
2166 "#ifdef VERTEX_SHADER\n"
2167 "void main\n"
2168 "(\n"
2169 "float4 gl_Vertex : POSITION,\n"
2170 "uniform float4x4 ModelViewProjectionMatrix : register(c8),\n"
2171 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2172 "uniform float4x4 TexMatrix : register(c0),\n"
2173 "uniform float3 EyePosition : register(c24),\n"
2174 "out float4 gl_Position : POSITION,\n"
2175 "out float2 TexCoord : TEXCOORD0,\n"
2176 "out float3 EyeVector : TEXCOORD1,\n"
2177 "out float4 ModelViewProjectionPosition : TEXCOORD2\n"
2178 ")\n"
2179 "{\n"
2180 "       TexCoord = mul(TexMatrix, gl_MultiTexCoord0).xy;\n"
2181 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2182 "       ModelViewProjectionPosition = gl_Position;\n"
2183 "}\n"
2184 "#endif\n"
2185 "\n"
2186 "#ifdef FRAGMENT_SHADER\n"
2187 "void main\n"
2188 "(\n"
2189 "float2 TexCoord : TEXCOORD0,\n"
2190 "float3 EyeVector : TEXCOORD1,\n"
2191 "float4 ModelViewProjectionPosition : TEXCOORD2,\n"
2192 "uniform sampler Texture_Normal : register(s0),\n"
2193 "uniform sampler Texture_Refraction : register(s3),\n"
2194 "uniform sampler Texture_Reflection : register(s7),\n"
2195 "uniform float4 DistortScaleRefractReflect : register(c14),\n"
2196 "uniform float4 ScreenScaleRefractReflect : register(c32),\n"
2197 "uniform float4 ScreenCenterRefractReflect : register(c31),\n"
2198 "uniform float4 RefractColor : register(c29),\n"
2199 "out float4 gl_FragColor : COLOR\n"
2200 ")\n"
2201 "{\n"
2202 "       float2 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect.xy * (1.0 / ModelViewProjectionPosition.w);\n"
2203 "       //float2 ScreenTexCoord = (ModelViewProjectionPosition.xy + normalize(tex2D(Texture_Normal, TexCoord).rgb - float3(0.5,0.5,0.5)).xy * DistortScaleRefractReflect.xy * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
2204 "       float2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
2205 "       float2 ScreenTexCoord = SafeScreenTexCoord + normalize(tex2D(Texture_Normal, TexCoord).rgb - float3(0.5,0.5,0.5)).xy * DistortScaleRefractReflect.xy;\n"
2206 "       // FIXME temporary hack to detect the case that the reflection\n"
2207 "       // gets blackened at edges due to leaving the area that contains actual\n"
2208 "       // content.\n"
2209 "       // Remove this 'ack once we have a better way to stop this thing from\n"
2210 "       // 'appening.\n"
2211 "       float f = min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord + float2(0.01, 0.01)).rgb) / 0.05);\n"
2212 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord + float2(0.01, -0.01)).rgb) / 0.05);\n"
2213 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord + float2(-0.01, 0.01)).rgb) / 0.05);\n"
2214 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord + float2(-0.01, -0.01)).rgb) / 0.05);\n"
2215 "       ScreenTexCoord = lerp(SafeScreenTexCoord, ScreenTexCoord, f);\n"
2216 "       gl_FragColor = float4(tex2D(Texture_Refraction, ScreenTexCoord).rgb, 1) * RefractColor;\n"
2217 "}\n"
2218 "#endif\n"
2219 "#else // !MODE_REFRACTION\n"
2220 "\n"
2221 "\n"
2222 "\n"
2223 "\n"
2224 "#ifdef MODE_WATER\n"
2225 "#ifdef VERTEX_SHADER\n"
2226 "\n"
2227 "void main\n"
2228 "(\n"
2229 "float4 gl_Vertex : POSITION,\n"
2230 "uniform float4x4 ModelViewProjectionMatrix : register(c8),\n"
2231 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2232 "float4 gl_MultiTexCoord1 : TEXCOORD1,\n"
2233 "float4 gl_MultiTexCoord2 : TEXCOORD2,\n"
2234 "float4 gl_MultiTexCoord3 : TEXCOORD3,\n"
2235 "uniform float4x4 TexMatrix : register(c0),\n"
2236 "uniform float3 EyePosition : register(c24),\n"
2237 "out float4 gl_Position : POSITION,\n"
2238 "out float2 TexCoord : TEXCOORD0,\n"
2239 "out float3 EyeVector : TEXCOORD1,\n"
2240 "out float4 ModelViewProjectionPosition : TEXCOORD2\n"
2241 ")\n"
2242 "{\n"
2243 "       TexCoord = mul(TexMatrix, gl_MultiTexCoord0).xy;\n"
2244 "       float3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
2245 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
2246 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
2247 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
2248 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2249 "       ModelViewProjectionPosition = gl_Position;\n"
2250 "}\n"
2251 "#endif\n"
2252 "\n"
2253 "#ifdef FRAGMENT_SHADER\n"
2254 "void main\n"
2255 "(\n"
2256 "float2 TexCoord : TEXCOORD0,\n"
2257 "float3 EyeVector : TEXCOORD1,\n"
2258 "float4 ModelViewProjectionPosition : TEXCOORD2,\n"
2259 "uniform sampler Texture_Normal : register(s0),\n"
2260 "uniform sampler Texture_Refraction : register(s3),\n"
2261 "uniform sampler Texture_Reflection : register(s7),\n"
2262 "uniform float4 DistortScaleRefractReflect : register(c14),\n"
2263 "uniform float4 ScreenScaleRefractReflect : register(c32),\n"
2264 "uniform float4 ScreenCenterRefractReflect : register(c31),\n"
2265 "uniform float4 RefractColor : register(c29),\n"
2266 "uniform float4 ReflectColor : register(c26),\n"
2267 "uniform float ReflectFactor : register(c27),\n"
2268 "uniform float ReflectOffset : register(c28),\n"
2269 "out float4 gl_FragColor : COLOR\n"
2270 ")\n"
2271 "{\n"
2272 "       float4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
2273 "       //float4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(tex2D(Texture_Normal, TexCoord).rgb - float3(0.5,0.5,0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
2274 "       float4 SafeScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
2275 "       //SafeScreenTexCoord = gl_FragCoord.xyxy * float4(1.0 / 1920.0, 1.0 / 1200.0, 1.0 / 1920.0, 1.0 / 1200.0);\n"
2276 "       float4 ScreenTexCoord = SafeScreenTexCoord + float2(normalize(tex2D(Texture_Normal, TexCoord).rgb - float3(0.5,0.5,0.5)).xy).xyxy * DistortScaleRefractReflect;\n"
2277 "       // FIXME temporary hack to detect the case that the reflection\n"
2278 "       // gets blackened at edges due to leaving the area that contains actual\n"
2279 "       // content.\n"
2280 "       // Remove this 'ack once we have a better way to stop this thing from\n"
2281 "       // 'appening.\n"
2282 "       float f = min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord.xy + float2(0.01, 0.01)).rgb) / 0.05);\n"
2283 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord.xy + float2(0.01, -0.01)).rgb) / 0.05);\n"
2284 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord.xy + float2(-0.01, 0.01)).rgb) / 0.05);\n"
2285 "       f      *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord.xy + float2(-0.01, -0.01)).rgb) / 0.05);\n"
2286 "       ScreenTexCoord.xy = lerp(SafeScreenTexCoord.xy, ScreenTexCoord.xy, f);\n"
2287 "       f  = min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord.zw + float2(0.01, 0.01)).rgb) / 0.05);\n"
2288 "       f *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord.zw + float2(0.01, -0.01)).rgb) / 0.05);\n"
2289 "       f *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord.zw + float2(-0.01, 0.01)).rgb) / 0.05);\n"
2290 "       f *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord.zw + float2(-0.01, -0.01)).rgb) / 0.05);\n"
2291 "       ScreenTexCoord.zw = lerp(SafeScreenTexCoord.zw, ScreenTexCoord.zw, f);\n"
2292 "       float Fresnel = pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 2.0) * ReflectFactor + ReflectOffset;\n"
2293 "       gl_FragColor = lerp(float4(tex2D(Texture_Refraction, ScreenTexCoord.xy).rgb, 1) * RefractColor, float4(tex2D(Texture_Reflection, ScreenTexCoord.zw).rgb, 1) * ReflectColor, Fresnel);\n"
2294 "}\n"
2295 "#endif\n"
2296 "#else // !MODE_WATER\n"
2297 "\n"
2298 "\n"
2299 "\n"
2300 "\n"
2301 "// 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"
2302 "\n"
2303 "// fragment shader specific:\n"
2304 "#ifdef FRAGMENT_SHADER\n"
2305 "\n"
2306 "#ifdef USEFOG\n"
2307 "float3 FogVertex(float3 surfacecolor, float3 FogColor, float3 EyeVectorModelSpace, float FogPlaneVertexDist, float FogRangeRecip, float FogPlaneViewDist, float FogHeightFade, sampler Texture_FogMask, sampler Texture_FogHeightTexture)\n"
2308 "{\n"
2309 "       float fogfrac;\n"
2310 "#ifdef USEFOGHEIGHTTEXTURE\n"
2311 "       float4 fogheightpixel = tex2D(Texture_FogHeightTexture, float2(1,1) + float2(FogPlaneVertexDist, FogPlaneViewDist) * (-2.0 * FogHeightFade));\n"
2312 "       fogfrac = fogheightpixel.a;\n"
2313 "       return lerp(fogheightpixel.rgb * FogColor, surfacecolor, tex2D(Texture_FogMask, float2(length(EyeVectorModelSpace)*fogfrac*FogRangeRecip, 0.0)).r);\n"
2314 "#else\n"
2315 "# ifdef USEFOGOUTSIDE\n"
2316 "       fogfrac = min(0.0, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0, min(0.0, FogPlaneVertexDist) * FogHeightFade);\n"
2317 "# else\n"
2318 "       fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0, FogPlaneVertexDist)) * min(1.0, (min(0.0, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);\n"
2319 "# endif\n"
2320 "       return lerp(FogColor, surfacecolor, tex2D(Texture_FogMask, float2(length(EyeVectorModelSpace)*fogfrac*FogRangeRecip, 0.0)).r);\n"
2321 "#endif\n"
2322 "}\n"
2323 "#endif\n"
2324 "\n"
2325 "#ifdef USEOFFSETMAPPING\n"
2326 "float2 OffsetMapping(float2 TexCoord, float OffsetMapping_Scale, float3 EyeVector, sampler Texture_Normal)\n"
2327 "{\n"
2328 "#ifdef USEOFFSETMAPPING_RELIEFMAPPING\n"
2329 "       // 14 sample relief mapping: linear search and then binary search\n"
2330 "       // this basically steps forward a small amount repeatedly until it finds\n"
2331 "       // itself inside solid, then jitters forward and back using decreasing\n"
2332 "       // amounts to find the impact\n"
2333 "       //float3 OffsetVector = float3(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * float2(-1, 1), -1);\n"
2334 "       //float3 OffsetVector = float3(normalize(EyeVector.xy) * OffsetMapping_Scale * float2(-1, 1), -1);\n"
2335 "       float3 OffsetVector = float3(normalize(EyeVector).xy * OffsetMapping_Scale * float2(-1, 1), -1);\n"
2336 "       float3 RT = float3(TexCoord, 1);\n"
2337 "       OffsetVector *= 0.1;\n"
2338 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2339 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2340 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2341 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2342 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2343 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2344 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2345 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2346 "       RT += OffsetVector *  step(tex2D(Texture_Normal, RT.xy).a, RT.z);\n"
2347 "       RT += OffsetVector * (step(tex2D(Texture_Normal, RT.xy).a, RT.z)          - 0.5);\n"
2348 "       RT += OffsetVector * (step(tex2D(Texture_Normal, RT.xy).a, RT.z) * 0.5    - 0.25);\n"
2349 "       RT += OffsetVector * (step(tex2D(Texture_Normal, RT.xy).a, RT.z) * 0.25   - 0.125);\n"
2350 "       RT += OffsetVector * (step(tex2D(Texture_Normal, RT.xy).a, RT.z) * 0.125  - 0.0625);\n"
2351 "       RT += OffsetVector * (step(tex2D(Texture_Normal, RT.xy).a, RT.z) * 0.0625 - 0.03125);\n"
2352 "       return RT.xy;\n"
2353 "#else\n"
2354 "       // 3 sample offset mapping (only 3 samples because of ATI Radeon 9500-9800/X300 limits)\n"
2355 "       // this basically moves forward the full distance, and then backs up based\n"
2356 "       // on height of samples\n"
2357 "       //float2 OffsetVector = float2(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * float2(-1, 1));\n"
2358 "       //float2 OffsetVector = float2(normalize(EyeVector.xy) * OffsetMapping_Scale * float2(-1, 1));\n"
2359 "       float2 OffsetVector = float2(normalize(EyeVector).xy * OffsetMapping_Scale * float2(-1, 1));\n"
2360 "       TexCoord += OffsetVector;\n"
2361 "       OffsetVector *= 0.333;\n"
2362 "       TexCoord -= OffsetVector * tex2D(Texture_Normal, TexCoord).a;\n"
2363 "       TexCoord -= OffsetVector * tex2D(Texture_Normal, TexCoord).a;\n"
2364 "       TexCoord -= OffsetVector * tex2D(Texture_Normal, TexCoord).a;\n"
2365 "       return TexCoord;\n"
2366 "#endif\n"
2367 "}\n"
2368 "#endif // USEOFFSETMAPPING\n"
2369 "\n"
2370 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USESHADOWMAPORTHO)\n"
2371 "#if defined(USESHADOWMAP2D)\n"
2372 "# ifdef USESHADOWMAPORTHO\n"
2373 "#  define GetShadowMapTC2D(dir, ShadowMap_Parameters) (min(dir, ShadowMap_Parameters.xyz))\n"
2374 "# else\n"
2375 "#  ifdef USESHADOWMAPVSDCT\n"
2376 "float3 GetShadowMapTC2D(float3 dir, float4 ShadowMap_Parameters, samplerCUBE Texture_CubeProjection)\n"
2377 "{\n"
2378 "       float3 adir = abs(dir);\n"
2379 "       float2 aparams = ShadowMap_Parameters.xy / max(max(adir.x, adir.y), adir.z);\n"
2380 "       float4 proj = texCUBE(Texture_CubeProjection, dir);\n"
2381 "       return float3(lerp(dir.xy, dir.zz, proj.xy) * aparams.x + proj.zw * ShadowMap_Parameters.z, aparams.y + ShadowMap_Parameters.w);\n"
2382 "}\n"
2383 "#  else\n"
2384 "float3 GetShadowMapTC2D(float3 dir, float4 ShadowMap_Parameters)\n"
2385 "{\n"
2386 "       float3 adir = abs(dir);\n"
2387 "       float ma = adir.z;\n"
2388 "       float4 proj = float4(dir, 2.5);\n"
2389 "       if (adir.x > ma) { ma = adir.x; proj = float4(dir.zyx, 0.5); }\n"
2390 "       if (adir.y > ma) { ma = adir.y; proj = float4(dir.xzy, 1.5); }\n"
2391 "#ifdef HLSL\n"
2392 "       return float3(proj.xy * ShadowMap_Parameters.x / ma + float2(0.5,0.5) + float2(proj.z < 0.0 ? 1.5 : 0.5, proj.w) * ShadowMap_Parameters.z, ma + 64 * ShadowMap_Parameters.w);\n"
2393 "#else\n"
2394 "       float2 aparams = ShadowMap_Parameters.xy / ma;\n"
2395 "       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"
2396 "#endif\n"
2397 "}\n"
2398 "#  endif\n"
2399 "# endif\n"
2400 "#endif // defined(USESHADOWMAP2D)\n"
2401 "\n"
2402 "# ifdef USESHADOWMAP2D\n"
2403 "#ifdef USESHADOWMAPVSDCT\n"
2404 "float ShadowMapCompare(float3 dir, sampler Texture_ShadowMap2D, float4 ShadowMap_Parameters, float2 ShadowMap_TextureScale, samplerCUBE Texture_CubeProjection)\n"
2405 "#else\n"
2406 "float ShadowMapCompare(float3 dir, sampler Texture_ShadowMap2D, float4 ShadowMap_Parameters, float2 ShadowMap_TextureScale)\n"
2407 "#endif\n"
2408 "{\n"
2409 "#ifdef USESHADOWMAPVSDCT\n"
2410 "       float3 shadowmaptc = GetShadowMapTC2D(dir, ShadowMap_Parameters, Texture_CubeProjection);\n"
2411 "#else\n"
2412 "       float3 shadowmaptc = GetShadowMapTC2D(dir, ShadowMap_Parameters);\n"
2413 "#endif\n"
2414 "       float f;\n"
2415 "\n"
2416 "#  ifdef USESHADOWSAMPLER\n"
2417 "#    ifdef USESHADOWMAPPCF\n"
2418 "#      define texval(x, y) tex2Dproj(Texture_ShadowMap2D, float4(center + float2(x, y)*ShadowMap_TextureScale, shadowmaptc.z, 1.0)).r  \n"
2419 "       float2 center = shadowmaptc.xy*ShadowMap_TextureScale;\n"
2420 "       f = dot(float4(0.25,0.25,0.25,0.25), float4(texval(-0.4, 1.0), texval(-1.0, -0.4), texval(0.4, -1.0), texval(1.0, 0.4)));\n"
2421 "#    else\n"
2422 "       f = tex2Dproj(Texture_ShadowMap2D, float4(shadowmaptc.xy*ShadowMap_TextureScale, shadowmaptc.z, 1.0)).r;\n"
2423 "#    endif\n"
2424 "#  else\n"
2425 "#    ifdef USESHADOWMAPPCF\n"
2426 "#     if defined(GL_ARB_texture_gather) || defined(GL_AMD_texture_texture4)\n"
2427 "#      ifdef GL_ARB_texture_gather\n"
2428 "#        define texval(x, y) textureGatherOffset(Texture_ShadowMap2D, center, int2(x, y))\n"
2429 "#      else\n"
2430 "#        define texval(x, y) texture4(Texture_ShadowMap2D, center + float2(x, y)*ShadowMap_TextureScale)\n"
2431 "#      endif\n"
2432 "       float2 offset = frac(shadowmaptc.xy - 0.5), center = (shadowmaptc.xy - offset)*ShadowMap_TextureScale;\n"
2433 "#      if USESHADOWMAPPCF > 1\n"
2434 "       float4 group1 = step(shadowmaptc.z, texval(-2.0, -2.0));\n"
2435 "       float4 group2 = step(shadowmaptc.z, texval( 0.0, -2.0));\n"
2436 "       float4 group3 = step(shadowmaptc.z, texval( 2.0, -2.0));\n"
2437 "       float4 group4 = step(shadowmaptc.z, texval(-2.0,  0.0));\n"
2438 "       float4 group5 = step(shadowmaptc.z, texval( 0.0,  0.0));\n"
2439 "       float4 group6 = step(shadowmaptc.z, texval( 2.0,  0.0));\n"
2440 "       float4 group7 = step(shadowmaptc.z, texval(-2.0,  2.0));\n"
2441 "       float4 group8 = step(shadowmaptc.z, texval( 0.0,  2.0));\n"
2442 "       float4 group9 = step(shadowmaptc.z, texval( 2.0,  2.0));\n"
2443 "       float4 locols = float4(group1.ab, group3.ab);\n"
2444 "       float4 hicols = float4(group7.rg, group9.rg);\n"
2445 "       locols.yz += group2.ab;\n"
2446 "       hicols.yz += group8.rg;\n"
2447 "       float4 midcols = float4(group1.rg, group3.rg) + float4(group7.ab, group9.ab) +\n"
2448 "                               float4(group4.rg, group6.rg) + float4(group4.ab, group6.ab) +\n"
2449 "                               lerp(locols, hicols, offset.y);\n"
2450 "       float4 cols = group5 + float4(group2.rg, group8.ab);\n"
2451 "       cols.xyz += lerp(midcols.xyz, midcols.yzw, offset.x);\n"
2452 "       f = dot(cols, float4(1.0/25.0));\n"
2453 "#      else\n"
2454 "       float4 group1 = step(shadowmaptc.z, texval(-1.0, -1.0));\n"
2455 "       float4 group2 = step(shadowmaptc.z, texval( 1.0, -1.0));\n"
2456 "       float4 group3 = step(shadowmaptc.z, texval(-1.0,  1.0));\n"
2457 "       float4 group4 = step(shadowmaptc.z, texval( 1.0,  1.0));\n"
2458 "       float4 cols = float4(group1.rg, group2.rg) + float4(group3.ab, group4.ab) +\n"
2459 "                               lerp(float4(group1.ab, group2.ab), float4(group3.rg, group4.rg), offset.y);\n"
2460 "       f = dot(lerp(cols.xyz, cols.yzw, offset.x), float3(1.0/9.0));\n"
2461 "#      endif\n"
2462 "#     else\n"
2463 "#      ifdef GL_EXT_gpu_shader4\n"
2464 "#        define texval(x, y) tex2DOffset(Texture_ShadowMap2D, center, int2(x, y)).r\n"
2465 "#      else\n"
2466 "#        define texval(x, y) texDepth2D(Texture_ShadowMap2D, center + float2(x, y)*ShadowMap_TextureScale).r  \n"
2467 "#      endif\n"
2468 "#      if USESHADOWMAPPCF > 1\n"
2469 "       float2 center = shadowmaptc.xy - 0.5, offset = frac(center);\n"
2470 "       center *= ShadowMap_TextureScale;\n"
2471 "       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"
2472 "       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"
2473 "       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"
2474 "       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"
2475 "       float4 cols = row2 + row3 + lerp(row1, row4, offset.y);\n"
2476 "       f = dot(lerp(cols.xyz, cols.yzw, offset.x), float3(1.0/9.0));\n"
2477 "#      else\n"
2478 "       float2 center = shadowmaptc.xy*ShadowMap_TextureScale, offset = frac(shadowmaptc.xy);\n"
2479 "       float3 row1 = step(shadowmaptc.z, float3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n"
2480 "       float3 row2 = step(shadowmaptc.z, float3(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0)));\n"
2481 "       float3 row3 = step(shadowmaptc.z, float3(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0)));\n"
2482 "       float3 cols = row2 + lerp(row1, row3, offset.y);\n"
2483 "       f = dot(lerp(cols.xy, cols.yz, offset.x), float2(0.25,0.25));\n"
2484 "#      endif\n"
2485 "#     endif\n"
2486 "#    else\n"
2487 "       f = step(shadowmaptc.z, tex2D(Texture_ShadowMap2D, shadowmaptc.xy*ShadowMap_TextureScale).r);\n"
2488 "#    endif\n"
2489 "#  endif\n"
2490 "#  ifdef USESHADOWMAPORTHO\n"
2491 "       return lerp(ShadowMap_Parameters.w, 1.0, f);\n"
2492 "#  else\n"
2493 "       return f;\n"
2494 "#  endif\n"
2495 "}\n"
2496 "# endif\n"
2497 "#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE) && !defined(USESHADOWMAPORTHO)\n"
2498 "#endif // FRAGMENT_SHADER\n"
2499 "\n"
2500 "\n"
2501 "\n"
2502 "\n"
2503 "#ifdef MODE_DEFERREDGEOMETRY\n"
2504 "#ifdef VERTEX_SHADER\n"
2505 "void main\n"
2506 "(\n"
2507 "float4 gl_Vertex : POSITION,\n"
2508 "uniform float4x4 ModelViewProjectionMatrix : register(c8),\n"
2509 "#ifdef USEVERTEXTEXTUREBLEND\n"
2510 "float4 gl_Color : COLOR0,\n"
2511 "#endif\n"
2512 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2513 "float4 gl_MultiTexCoord1 : TEXCOORD1,\n"
2514 "float4 gl_MultiTexCoord2 : TEXCOORD2,\n"
2515 "float4 gl_MultiTexCoord3 : TEXCOORD3,\n"
2516 "uniform float4x4 TexMatrix : register(c0),\n"
2517 "#ifdef USEVERTEXTEXTUREBLEND\n"
2518 "uniform float4x4 BackgroundTexMatrix : register(c4),\n"
2519 "#endif\n"
2520 "uniform float4x4 ModelViewMatrix : register(c12),\n"
2521 "#ifdef USEOFFSETMAPPING\n"
2522 "uniform float3 EyePosition : register(c24),\n"
2523 "#endif\n"
2524 "out float4 gl_Position : POSITION,\n"
2525 "#ifdef USEVERTEXTEXTUREBLEND\n"
2526 "out float4 gl_FrontColor : COLOR,\n"
2527 "#endif\n"
2528 "out float4 TexCoordBoth : TEXCOORD0,\n"
2529 "#ifdef USEOFFSETMAPPING\n"
2530 "out float3 EyeVector : TEXCOORD2,\n"
2531 "#endif\n"
2532 "out float3 VectorS : TEXCOORD5, // direction of S texcoord (sometimes crudely called tangent)\n"
2533 "out float3 VectorT : TEXCOORD6, // direction of T texcoord (sometimes crudely called binormal)\n"
2534 "out float4 VectorR : TEXCOORD7 // direction of R texcoord (surface normal), Depth value\n"
2535 ")\n"
2536 "{\n"
2537 "       TexCoordBoth = mul(TexMatrix, gl_MultiTexCoord0);\n"
2538 "#ifdef USEVERTEXTEXTUREBLEND\n"
2539 "#ifdef HLSL\n"
2540 "       gl_FrontColor = gl_Color.bgra; // NOTE: D3DCOLOR is backwards\n"
2541 "#else\n"
2542 "       gl_FrontColor = gl_Color; // Cg is forward\n"
2543 "#endif\n"
2544 "       TexCoordBoth.zw = float2(Backgroundmul(TexMatrix, gl_MultiTexCoord0));\n"
2545 "#endif\n"
2546 "\n"
2547 "       // transform unnormalized eye direction into tangent space\n"
2548 "#ifdef USEOFFSETMAPPING\n"
2549 "       float3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
2550 "       EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
2551 "       EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
2552 "       EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
2553 "#endif\n"
2554 "\n"
2555 "       VectorS = mul(ModelViewMatrix, float4(gl_MultiTexCoord1.xyz, 0)).xyz;\n"
2556 "       VectorT = mul(ModelViewMatrix, float4(gl_MultiTexCoord2.xyz, 0)).xyz;\n"
2557 "       VectorR.xyz = mul(ModelViewMatrix, float4(gl_MultiTexCoord3.xyz, 0)).xyz;\n"
2558 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2559 "       VectorR.w = gl_Position.z;\n"
2560 "}\n"
2561 "#endif // VERTEX_SHADER\n"
2562 "\n"
2563 "#ifdef FRAGMENT_SHADER\n"
2564 "void main\n"
2565 "(\n"
2566 "float4 TexCoordBoth : TEXCOORD0,\n"
2567 "float3 EyeVector : TEXCOORD2,\n"
2568 "float3 VectorS : TEXCOORD5, // direction of S texcoord (sometimes crudely called tangent)\n"
2569 "float3 VectorT : TEXCOORD6, // direction of T texcoord (sometimes crudely called binormal)\n"
2570 "float4 VectorR : TEXCOORD7, // direction of R texcoord (surface normal), Depth value\n"
2571 "uniform sampler Texture_Normal : register(s0),\n"
2572 "#ifdef USEALPHAKILL\n"
2573 "uniform sampler Texture_Color : register(s1),\n"
2574 "#endif\n"
2575 "uniform sampler Texture_Gloss : register(s2),\n"
2576 "#ifdef USEVERTEXTEXTUREBLEND\n"
2577 "uniform sampler Texture_SecondaryNormal : register(s4),\n"
2578 "uniform sampler Texture_SecondaryGloss : register(s6),\n"
2579 "#endif\n"
2580 "#ifdef USEOFFSETMAPPING\n"
2581 "uniform float OffsetMapping_Scale : register(c24),\n"
2582 "#endif\n"
2583 "uniform half SpecularPower : register(c36),\n"
2584 "#ifdef HLSL\n"
2585 "out float4 gl_FragData0 : COLOR0,\n"
2586 "out float4 gl_FragData1 : COLOR1\n"
2587 "#else\n"
2588 "out float4 gl_FragColor : COLOR\n"
2589 "#endif\n"
2590 ")\n"
2591 "{\n"
2592 "       float2 TexCoord = TexCoordBoth.xy;\n"
2593 "#ifdef USEOFFSETMAPPING\n"
2594 "       // apply offsetmapping\n"
2595 "       float2 TexCoordOffset = OffsetMapping(TexCoord, OffsetMapping_Scale, EyeVector, Texture_Normal);\n"
2596 "#define TexCoord TexCoordOffset\n"
2597 "#endif\n"
2598 "\n"
2599 "#ifdef USEALPHAKILL\n"
2600 "       if (tex2D(Texture_Color, TexCoord).a < 0.5)\n"
2601 "               discard;\n"
2602 "#endif\n"
2603 "\n"
2604 "#ifdef USEVERTEXTEXTUREBLEND\n"
2605 "       float alpha = tex2D(Texture_Color, TexCoord).a;\n"
2606 "       float terrainblend = clamp(float(gl_FrontColor.a) * alpha * 2.0 - 0.5, float(0.0), float(1.0));\n"
2607 "       //float terrainblend = min(float(gl_FrontColor.a) * alpha * 2.0, float(1.0));\n"
2608 "       //float terrainblend = float(gl_FrontColor.a) * alpha > 0.5;\n"
2609 "#endif\n"
2610 "\n"
2611 "#ifdef USEVERTEXTEXTUREBLEND\n"
2612 "       float3 surfacenormal = lerp(tex2D(Texture_SecondaryNormal, TexCoord2).rgb, tex2D(Texture_Normal, TexCoord).rgb, terrainblend) - float3(0.5, 0.5, 0.5);\n"
2613 "       float a = lerp(tex2D(Texture_SecondaryGloss, TexCoord2).a, tex2D(Texture_Gloss, TexCoord).a, terrainblend);\n"
2614 "#else\n"
2615 "       float3 surfacenormal = tex2D(Texture_Normal, TexCoord).rgb - float3(0.5, 0.5, 0.5);\n"
2616 "       float a = tex2D(Texture_Gloss, TexCoord).a;\n"
2617 "#endif\n"
2618 "\n"
2619 "#ifdef HLSL\n"
2620 "       gl_FragData0 = float4(normalize(surfacenormal.x * VectorS + surfacenormal.y * VectorT + surfacenormal.z * VectorR.xyz) * 0.5 + float3(0.5, 0.5, 0.5), a);\n"
2621 "       float Depth = VectorR.w / 256.0;\n"
2622 "       float4 depthcolor = float4(Depth,Depth*65536.0/255.0,Depth*16777216.0/255.0,0.0);\n"
2623 "//     float4 depthcolor = float4(Depth,Depth*256.0,Depth*65536.0,0.0);\n"
2624 "       depthcolor.yz -= floor(depthcolor.yz);\n"
2625 "       gl_FragData1 = depthcolor;\n"
2626 "#else\n"
2627 "       gl_FragColor = float4(normalize(surfacenormal.x * VectorS + surfacenormal.y * VectorT + surfacenormal.z * VectorR) * 0.5 + float3(0.5, 0.5, 0.5), a);\n"
2628 "#endif\n"
2629 "}\n"
2630 "#endif // FRAGMENT_SHADER\n"
2631 "#else // !MODE_DEFERREDGEOMETRY\n"
2632 "\n"
2633 "\n"
2634 "\n"
2635 "\n"
2636 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
2637 "#ifdef VERTEX_SHADER\n"
2638 "void main\n"
2639 "(\n"
2640 "float4 gl_Vertex : POSITION,\n"
2641 "uniform float4x4 ModelViewProjectionMatrix : register(c8),\n"
2642 "uniform float4x4 ModelViewMatrix : register(c12),\n"
2643 "out float4 gl_Position : POSITION,\n"
2644 "out float4 ModelViewPosition : TEXCOORD0\n"
2645 ")\n"
2646 "{\n"
2647 "       ModelViewPosition = mul(ModelViewMatrix, gl_Vertex);\n"
2648 "       gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n"
2649 "}\n"
2650 "#endif // VERTEX_SHADER\n"
2651 "\n"
2652 "#ifdef FRAGMENT_SHADER\n"
2653 "void main\n"
2654 "(\n"
2655 "#ifdef HLSL\n"
2656 "float2 Pixel : VPOS,\n"
2657 "#else\n"
2658 "float2 Pixel : WPOS,\n"
2659 "#endif\n"
2660 "float4 ModelViewPosition : TEXCOORD0,\n"
2661 "uniform float4x4 ViewToLight : register(c44),\n"
2662 "uniform float2 ScreenToDepth : register(c33), // ScreenToDepth = float2(Far / (Far - Near), Far * Near / (Near - Far));\n"
2663 "uniform float3 LightPosition : register(c23),\n"
2664 "uniform half2 PixelToScreenTexCoord : register(c42),\n"
2665 "uniform half3 DeferredColor_Ambient : register(c9),\n"
2666 "uniform half3 DeferredColor_Diffuse : register(c10),\n"
2667 "#ifdef USESPECULAR\n"
2668 "uniform half3 DeferredColor_Specular : register(c11),\n"
2669 "uniform half SpecularPower : register(c36),\n"
2670 "#endif\n"
2671 "uniform sampler Texture_Attenuation : register(s9),\n"
2672 "uniform sampler Texture_ScreenDepth : register(s13),\n"
2673 "uniform sampler Texture_ScreenNormalMap : register(s14),\n"
2674 "\n"
2675 "#ifdef USECUBEFILTER\n"
2676 "uniform samplerCUBE Texture_Cube : register(s10),\n"
2677 "#endif\n"
2678 "\n"
2679 "#ifdef USESHADOWMAP2D\n"
2680 "# ifdef USESHADOWSAMPLER\n"
2681 "uniform sampler Texture_ShadowMap2D : register(s15),\n"
2682 "# else\n"
2683 "uniform sampler Texture_ShadowMap2D : register(s15),\n"
2684 "# endif\n"
2685 "#endif\n"
2686 "\n"
2687 "#ifdef USESHADOWMAPVSDCT\n"
2688 "uniform samplerCUBE Texture_CubeProjection : register(s12),\n"
2689 "#endif\n"
2690 "\n"
2691 "#if defined(USESHADOWMAP2D)\n"
2692 "uniform float2 ShadowMap_TextureScale : register(c35),\n"
2693 "uniform float4 ShadowMap_Parameters : register(c34),\n"
2694 "#endif\n"
2695 "\n"
2696 "out float4 gl_FragData0 : COLOR0,\n"
2697 "out float4 gl_FragData1 : COLOR1\n"
2698 ")\n"
2699 "{\n"
2700 "       // calculate viewspace pixel position\n"
2701 "       float2 ScreenTexCoord = Pixel * PixelToScreenTexCoord;\n"
2702 "       //ScreenTexCoord.y = ScreenTexCoord.y * -1 + 1; // Cg is opposite?\n"
2703 "       float3 position;\n"
2704 "#ifdef HLSL\n"
2705 "       position.z = texDepth2D(Texture_ScreenDepth, ScreenTexCoord) * 256.0;\n"
2706 "#else\n"
2707 "       position.z = ScreenToDepth.y / (texDepth2D(Texture_ScreenDepth, ScreenTexCoord) + ScreenToDepth.x);\n"
2708 "#endif\n"
2709 "       position.xy = ModelViewPosition.xy * (position.z / ModelViewPosition.z);\n"
2710 "       // decode viewspace pixel normal\n"
2711 "       half4 normalmap = half4(tex2D(Texture_ScreenNormalMap, ScreenTexCoord));\n"
2712 "       half3 surfacenormal = half3(normalize(normalmap.rgb - half3(0.5,0.5,0.5)));\n"
2713 "       // surfacenormal = pixel normal in viewspace\n"
2714 "       // LightVector = pixel to light in viewspace\n"
2715 "       // CubeVector = position in lightspace\n"
2716 "       // eyevector = pixel to view in viewspace\n"
2717 "       float3 CubeVector = mul(ViewToLight, float4(position,1)).xyz;\n"
2718 "       half fade = half(tex2D(Texture_Attenuation, float2(length(CubeVector), 0.0)).r);\n"
2719 "#ifdef USEDIFFUSE\n"
2720 "       // calculate diffuse shading\n"
2721 "       half3 lightnormal = half3(normalize(LightPosition - position));\n"
2722 "       half diffuse = half(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
2723 "#endif\n"
2724 "#ifdef USESPECULAR\n"
2725 "       // calculate directional shading\n"
2726 "       float3 eyevector = position * -1.0;\n"
2727 "#  ifdef USEEXACTSPECULARMATH\n"
2728 "       half specular = half(pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(eyevector)))*-1.0, 0.0)), SpecularPower * normalmap.a));\n"
2729 "#  else\n"
2730 "       half3 specularnormal = half3(normalize(lightnormal + half3(normalize(eyevector))));\n"
2731 "       half specular = half(pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * normalmap.a));\n"
2732 "#  endif\n"
2733 "#endif\n"
2734 "\n"
2735 "#if defined(USESHADOWMAP2D)\n"
2736 "       fade *= half(ShadowMapCompare(CubeVector, Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale\n"
2737 "#ifdef USESHADOWMAPVSDCT\n"
2738 ", Texture_CubeProjection\n"
2739 "#endif\n"
2740 "       ));\n"
2741 "#endif\n"
2742 "\n"
2743 "#ifdef USEDIFFUSE\n"
2744 "       gl_FragData0 = float4((DeferredColor_Ambient + DeferredColor_Diffuse * diffuse) * fade, 1.0);\n"
2745 "#else\n"
2746 "       gl_FragData0 = float4(DeferredColor_Ambient * fade, 1.0);\n"
2747 "#endif\n"
2748 "#ifdef USESPECULAR\n"
2749 "       gl_FragData1 = float4(DeferredColor_Specular * (specular * fade), 1.0);\n"
2750 "#else\n"
2751 "       gl_FragData1 = float4(0.0, 0.0, 0.0, 1.0);\n"
2752 "#endif\n"
2753 "\n"
2754 "# ifdef USECUBEFILTER\n"
2755 "       float3 cubecolor = texCUBE(Texture_Cube, CubeVector).rgb;\n"
2756 "       gl_FragData0.rgb *= cubecolor;\n"
2757 "       gl_FragData1.rgb *= cubecolor;\n"
2758 "# endif\n"
2759 "}\n"
2760 "#endif // FRAGMENT_SHADER\n"
2761 "#else // !MODE_DEFERREDLIGHTSOURCE\n"
2762 "\n"
2763 "\n"
2764 "\n"
2765 "\n"
2766 "#ifdef VERTEX_SHADER\n"
2767 "void main\n"
2768 "(\n"
2769 "float4 gl_Vertex : POSITION,\n"
2770 "uniform float4x4 ModelViewProjectionMatrix : register(c8),\n"
2771 "#if defined(USEVERTEXTEXTUREBLEND) || defined(MODE_VERTEXCOLOR)\n"
2772 "float4 gl_Color : COLOR0,\n"
2773 "#endif\n"
2774 "float4 gl_MultiTexCoord0 : TEXCOORD0,\n"
2775 "float4 gl_MultiTexCoord1 : TEXCOORD1,\n"
2776 "float4 gl_MultiTexCoord2 : TEXCOORD2,\n"
2777 "float4 gl_MultiTexCoord3 : TEXCOORD3,\n"
2778 "float4 gl_MultiTexCoord4 : TEXCOORD4,\n"
2779 "\n"
2780 "uniform float3 EyePosition : register(c24),\n"
2781 "uniform float4x4 TexMatrix : register(c0),\n"
2782 "#ifdef USEVERTEXTEXTUREBLEND\n"
2783 "uniform float4x4 BackgroundTexMatrix : register(c4),\n"
2784 "#endif\n"
2785 "#ifdef MODE_LIGHTSOURCE\n"
2786 "uniform float4x4 ModelToLight : register(c20),\n"
2787 "#endif\n"
2788 "#ifdef MODE_LIGHTSOURCE\n"
2789 "uniform float3 LightPosition : register(c27),\n"
2790 "#endif\n"
2791 "#ifdef MODE_LIGHTDIRECTION\n"
2792 "uniform float3 LightDir : register(c26),\n"
2793 "#endif\n"
2794 "uniform float4 FogPlane : register(c25),\n"
2795 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
2796 "uniform float3 LightPosition : register(c27),\n"
2797 "#endif\n"
2798 "#ifdef USESHADOWMAPORTHO\n"
2799 "uniform float4x4 ShadowMapMatrix : register(c16),\n"
2800 "#endif\n"
2801 "#if defined(MODE_VERTEXCOLOR) || defined(USEVERTEXTEXTUREBLEND)\n"
2802 "out float4 gl_FrontColor : COLOR,\n"
2803 "#endif\n"
2804 "out float4 TexCoordBoth : TEXCOORD0,\n"
2805 "#ifdef USELIGHTMAP\n"
2806 "out float2 TexCoordLightmap : TEXCOORD1,\n"
2807 "#endif\n"
2808 "#ifdef USEEYEVECTOR\n"
2809 "out float3 EyeVector : TEXCOORD2,\n"
2810 "#endif\n"
2811 "#ifdef USEREFLECTION\n"
2812 "out float4 ModelViewProjectionPosition : TEXCOORD3,\n"
2813 "#endif\n"
2814 "#ifdef USEFOG\n"
2815 "out float4 EyeVectorModelSpaceFogPlaneVertexDist : TEXCOORD4,\n"
2816 "#endif\n"
2817 "#if defined(MODE_LIGHTDIRECTION) && defined(USEDIFFUSE) || defined(USEDIFFUSE)\n"
2818 "out float3 LightVector : TEXCOORD1,\n"
2819 "#endif\n"
2820 "#ifdef MODE_LIGHTSOURCE\n"
2821 "out float3 CubeVector : TEXCOORD3,\n"
2822 "#endif\n"
2823 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY) || defined(USEREFLECTCUBE)\n"
2824 "out float3 VectorS : TEXCOORD5, // direction of S texcoord (sometimes crudely called tangent)\n"
2825 "out float3 VectorT : TEXCOORD6, // direction of T texcoord (sometimes crudely called binormal)\n"
2826 "out float3 VectorR : TEXCOORD7, // direction of R texcoord (surface normal)\n"
2827 "#endif\n"
2828 "#ifdef USESHADOWMAPORTHO\n"
2829 "out float3 ShadowMapTC : TEXCOORD3, // CONFLICTS WITH USEREFLECTION!\n"
2830 "#endif\n"
2831 "out float4 gl_Position : POSITION\n"
2832 ")\n"
2833 "{\n"
2834 "#if defined(MODE_VERTEXCOLOR) || defined(USEVERTEXTEXTUREBLEND)\n"
2835 "#ifdef HLSL\n"
2836 "       gl_FrontColor = gl_Color.bgra; // NOTE: D3DCOLOR is backwards\n"
2837 "#else\n"
2838 "       gl_FrontColor = gl_Color; // Cg is forward\n"
2839 "#endif\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 = gl_MultiTexCoord4.xy;\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 = mul(ModelToLight, gl_Vertex).xyz;\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 = mul(ShadowMapMatrix, gl_Position).xyz;\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 "#ifdef HLSL\n"
2912 "float2 Pixel : VPOS,\n"
2913 "#else\n"
2914 "float2 Pixel : WPOS,\n"
2915 "#endif\n"
2916 "#endif\n"
2917 "float4 gl_FrontColor : COLOR,\n"
2918 "float4 TexCoordBoth : TEXCOORD0,\n"
2919 "#ifdef USELIGHTMAP\n"
2920 "float2 TexCoordLightmap : TEXCOORD1,\n"
2921 "#endif\n"
2922 "#ifdef USEEYEVECTOR\n"
2923 "float3 EyeVector : TEXCOORD2,\n"
2924 "#endif\n"
2925 "#ifdef USEREFLECTION\n"
2926 "float4 ModelViewProjectionPosition : TEXCOORD3,\n"
2927 "#endif\n"
2928 "#ifdef USEFOG\n"
2929 "float4 EyeVectorModelSpaceFogPlaneVertexDist : TEXCOORD4,\n"
2930 "#endif\n"
2931 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_LIGHTDIRECTION)\n"
2932 "float3 LightVector : TEXCOORD1,\n"
2933 "#endif\n"
2934 "#ifdef MODE_LIGHTSOURCE\n"
2935 "float3 CubeVector : TEXCOORD3,\n"
2936 "#endif\n"
2937 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
2938 "float4 ModelViewPosition : TEXCOORD0,\n"
2939 "#endif\n"
2940 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY) || defined(USEREFLECTCUBE)\n"
2941 "float3 VectorS : TEXCOORD5, // direction of S texcoord (sometimes crudely called tangent)\n"
2942 "float3 VectorT : TEXCOORD6, // direction of T texcoord (sometimes crudely called binormal)\n"
2943 "float3 VectorR : TEXCOORD7, // direction of R texcoord (surface normal)\n"
2944 "#endif\n"
2945 "#ifdef USESHADOWMAPORTHO\n"
2946 "float3 ShadowMapTC : TEXCOORD3, // CONFLICTS WITH USEREFLECTION!\n"
2947 "#endif\n"
2948 "\n"
2949 "uniform sampler Texture_Normal : register(s0),\n"
2950 "uniform sampler Texture_Color : register(s1),\n"
2951 "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
2952 "uniform sampler Texture_Gloss : register(s2),\n"
2953 "#endif\n"
2954 "#ifdef USEGLOW\n"
2955 "uniform sampler Texture_Glow : register(s3),\n"
2956 "#endif\n"
2957 "#ifdef USEVERTEXTEXTUREBLEND\n"
2958 "uniform sampler Texture_SecondaryNormal : register(s4),\n"
2959 "uniform sampler Texture_SecondaryColor : register(s5),\n"
2960 "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
2961 "uniform sampler Texture_SecondaryGloss : register(s6),\n"
2962 "#endif\n"
2963 "#ifdef USEGLOW\n"
2964 "uniform sampler Texture_SecondaryGlow : register(s7),\n"
2965 "#endif\n"
2966 "#endif\n"
2967 "#ifdef USECOLORMAPPING\n"
2968 "uniform sampler Texture_Pants : register(s4),\n"
2969 "uniform sampler Texture_Shirt : register(s7),\n"
2970 "#endif\n"
2971 "#ifdef USEFOG\n"
2972 "uniform sampler Texture_FogHeightTexture : register(s14),\n"
2973 "uniform sampler Texture_FogMask : register(s8),\n"
2974 "#endif\n"
2975 "#ifdef USELIGHTMAP\n"
2976 "uniform sampler Texture_Lightmap : register(s9),\n"
2977 "#endif\n"
2978 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
2979 "uniform sampler Texture_Deluxemap : register(s10),\n"
2980 "#endif\n"
2981 "#ifdef USEREFLECTION\n"
2982 "uniform sampler Texture_Reflection : register(s7),\n"
2983 "#endif\n"
2984 "\n"
2985 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
2986 "uniform sampler Texture_ScreenDepth : register(s13),\n"
2987 "uniform sampler Texture_ScreenNormalMap : register(s14),\n"
2988 "#endif\n"
2989 "#ifdef USEDEFERREDLIGHTMAP\n"
2990 "uniform sampler Texture_ScreenDepth : register(s13),\n"
2991 "uniform sampler Texture_ScreenNormalMap : register(s14),\n"
2992 "uniform sampler Texture_ScreenDiffuse : register(s11),\n"
2993 "uniform sampler Texture_ScreenSpecular : register(s12),\n"
2994 "#endif\n"
2995 "\n"
2996 "#ifdef USECOLORMAPPING\n"
2997 "uniform half3 Color_Pants : register(c7),\n"
2998 "uniform half3 Color_Shirt : register(c8),\n"
2999 "#endif\n"
3000 "#ifdef USEFOG\n"
3001 "uniform float3 FogColor : register(c16),\n"
3002 "uniform float FogRangeRecip : register(c20),\n"
3003 "uniform float FogPlaneViewDist : register(c19),\n"
3004 "uniform float FogHeightFade : register(c17),\n"
3005 "#endif\n"
3006 "\n"
3007 "#ifdef USEOFFSETMAPPING\n"
3008 "uniform float OffsetMapping_Scale : register(c24),\n"
3009 "#endif\n"
3010 "\n"
3011 "#ifdef USEDEFERREDLIGHTMAP\n"
3012 "uniform half2 PixelToScreenTexCoord : register(c42),\n"
3013 "uniform half3 DeferredMod_Diffuse : register(c12),\n"
3014 "uniform half3 DeferredMod_Specular : register(c13),\n"
3015 "#endif\n"
3016 "uniform half3 Color_Ambient : register(c3),\n"
3017 "uniform half3 Color_Diffuse : register(c4),\n"
3018 "uniform half3 Color_Specular : register(c5),\n"
3019 "uniform half SpecularPower : register(c36),\n"
3020 "#ifdef USEGLOW\n"
3021 "uniform half3 Color_Glow : register(c6),\n"
3022 "#endif\n"
3023 "uniform half Alpha : register(c0),\n"
3024 "#ifdef USEREFLECTION\n"
3025 "uniform float4 DistortScaleRefractReflect : register(c14),\n"
3026 "uniform float4 ScreenScaleRefractReflect : register(c32),\n"
3027 "uniform float4 ScreenCenterRefractReflect : register(c31),\n"
3028 "uniform half4 ReflectColor : register(c26),\n"
3029 "#endif\n"
3030 "#ifdef USEREFLECTCUBE\n"
3031 "uniform float4x4 ModelToReflectCube : register(c48),\n"
3032 "uniform sampler Texture_ReflectMask : register(s5),\n"
3033 "uniform samplerCUBE Texture_ReflectCube : register(s6),\n"
3034 "#endif\n"
3035 "#ifdef MODE_LIGHTDIRECTION\n"
3036 "uniform half3 LightColor : register(c21),\n"
3037 "#endif\n"
3038 "#ifdef MODE_LIGHTSOURCE\n"
3039 "uniform half3 LightColor : register(c21),\n"
3040 "#endif\n"
3041 "\n"
3042 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE)\n"
3043 "uniform sampler Texture_Attenuation : register(s9),\n"
3044 "uniform samplerCUBE Texture_Cube : register(s10),\n"
3045 "#endif\n"
3046 "\n"
3047 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USESHADOWMAPORTHO)\n"
3048 "\n"
3049 "#ifdef USESHADOWMAP2D\n"
3050 "# ifdef USESHADOWSAMPLER\n"
3051 "uniform sampler Texture_ShadowMap2D : register(s15),\n"
3052 "# else\n"
3053 "uniform sampler Texture_ShadowMap2D : register(s15),\n"
3054 "# endif\n"
3055 "#endif\n"
3056 "\n"
3057 "#ifdef USESHADOWMAPVSDCT\n"
3058 "uniform samplerCUBE Texture_CubeProjection : register(s12),\n"
3059 "#endif\n"
3060 "\n"
3061 "#if defined(USESHADOWMAP2D)\n"
3062 "uniform float2 ShadowMap_TextureScale : register(c35),\n"
3063 "uniform float4 ShadowMap_Parameters : register(c34),\n"
3064 "#endif\n"
3065 "#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE) && !defined(USESHADOWMAPORTHO)\n"
3066 "\n"
3067 "out float4 gl_FragColor : COLOR\n"
3068 ")\n"
3069 "{\n"
3070 "       float2 TexCoord = TexCoordBoth.xy;\n"
3071 "#ifdef USEVERTEXTEXTUREBLEND\n"
3072 "       float2 TexCoord2 = TexCoordBoth.zw;\n"
3073 "#endif\n"
3074 "#ifdef USEOFFSETMAPPING\n"
3075 "       // apply offsetmapping\n"
3076 "       float2 TexCoordOffset = OffsetMapping(TexCoord, OffsetMapping_Scale, EyeVector, Texture_Normal);\n"
3077 "#define TexCoord TexCoordOffset\n"
3078 "#endif\n"
3079 "\n"
3080 "       // combine the diffuse textures (base, pants, shirt)\n"
3081 "       half4 color = half4(tex2D(Texture_Color, TexCoord));\n"
3082 "#ifdef USEALPHAKILL\n"
3083 "       if (color.a < 0.5)\n"
3084 "               discard;\n"
3085 "#endif\n"
3086 "       color.a *= Alpha;\n"
3087 "#ifdef USECOLORMAPPING\n"
3088 "       color.rgb += half3(tex2D(Texture_Pants, TexCoord).rgb) * Color_Pants + half3(tex2D(Texture_Shirt, TexCoord).rgb) * Color_Shirt;\n"
3089 "#endif\n"
3090 "#ifdef USEVERTEXTEXTUREBLEND\n"
3091 "       half terrainblend = clamp(half(gl_FrontColor.a) * color.a * 2.0 - 0.5, half(0.0), half(1.0));\n"
3092 "       //half terrainblend = min(half(gl_FrontColor.a) * color.a * 2.0, half(1.0));\n"
3093 "       //half terrainblend = half(gl_FrontColor.a) * color.a > 0.5;\n"
3094 "       color.rgb = half3(lerp(tex2D(Texture_SecondaryColor, TexCoord2).rgb, float3(color.rgb), terrainblend));\n"
3095 "       color.a = 1.0;\n"
3096 "       //color = half4(lerp(float4(1, 0, 0, 1), color, terrainblend));\n"
3097 "#endif\n"
3098 "\n"
3099 "       // get the surface normal\n"
3100 "#ifdef USEVERTEXTEXTUREBLEND\n"
3101 "       half3 surfacenormal = normalize(half3(lerp(tex2D(Texture_SecondaryNormal, TexCoord2).rgb, tex2D(Texture_Normal, TexCoord).rgb, terrainblend)) - half3(0.5, 0.5, 0.5));\n"
3102 "#else\n"
3103 "       half3 surfacenormal = half3(normalize(half3(tex2D(Texture_Normal, TexCoord).rgb) - half3(0.5, 0.5, 0.5)));\n"
3104 "#endif\n"
3105 "\n"
3106 "       // get the material colors\n"
3107 "       half3 diffusetex = color.rgb;\n"
3108 "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
3109 "# ifdef USEVERTEXTEXTUREBLEND\n"
3110 "       half4 glosstex = half4(lerp(tex2D(Texture_SecondaryGloss, TexCoord2), tex2D(Texture_Gloss, TexCoord), terrainblend));\n"
3111 "# else\n"
3112 "       half4 glosstex = half4(tex2D(Texture_Gloss, TexCoord));\n"
3113 "# endif\n"
3114 "#endif\n"
3115 "\n"
3116 "#ifdef USEREFLECTCUBE\n"
3117 "       float3 TangentReflectVector = reflect(-EyeVector, surfacenormal);\n"
3118 "       float3 ModelReflectVector = TangentReflectVector.x * VectorS + TangentReflectVector.y * VectorT + TangentReflectVector.z * VectorR;\n"
3119 "       float3 ReflectCubeTexCoord = mul(ModelToReflectCube, float4(ModelReflectVector, 0)).xyz;\n"
3120 "       diffusetex += half3(tex2D(Texture_ReflectMask, TexCoord).rgb) * half3(texCUBE(Texture_ReflectCube, ReflectCubeTexCoord).rgb);\n"
3121 "#endif\n"
3122 "\n"
3123 "\n"
3124 "\n"
3125 "\n"
3126 "#ifdef MODE_LIGHTSOURCE\n"
3127 "       // light source\n"
3128 "#ifdef USEDIFFUSE\n"
3129 "       half3 lightnormal = half3(normalize(LightVector));\n"
3130 "       half diffuse = half(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
3131 "       color.rgb = diffusetex * (Color_Ambient + diffuse * Color_Diffuse);\n"
3132 "#ifdef USESPECULAR\n"
3133 "#ifdef USEEXACTSPECULARMATH\n"
3134 "       half specular = half(pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a));\n"
3135 "#else\n"
3136 "       half3 specularnormal = half3(normalize(lightnormal + half3(normalize(EyeVector))));\n"
3137 "       half specular = half(pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a));\n"
3138 "#endif\n"
3139 "       color.rgb += glosstex.rgb * (specular * Color_Specular);\n"
3140 "#endif\n"
3141 "#else\n"
3142 "       color.rgb = diffusetex * Color_Ambient;\n"
3143 "#endif\n"
3144 "       color.rgb *= LightColor;\n"
3145 "       color.rgb *= half(tex2D(Texture_Attenuation, float2(length(CubeVector), 0.0)).r);\n"
3146 "#if defined(USESHADOWMAP2D)\n"
3147 "       color.rgb *= half(ShadowMapCompare(CubeVector, Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale\n"
3148 "#ifdef USESHADOWMAPVSDCT\n"
3149 ", Texture_CubeProjection\n"
3150 "#endif\n"
3151 "       ));\n"
3152 "\n"
3153 "#endif\n"
3154 "# ifdef USECUBEFILTER\n"
3155 "       color.rgb *= half3(texCUBE(Texture_Cube, CubeVector).rgb);\n"
3156 "# endif\n"
3157 "\n"
3158 "#ifdef USESHADOWMAP2D\n"
3159 "#ifdef USESHADOWMAPVSDCT\n"
3160 "//     float3 shadowmaptc = GetShadowMapTC2D(CubeVector, ShadowMap_Parameters, Texture_CubeProjection);\n"
3161 "#else\n"
3162 "//     float3 shadowmaptc = GetShadowMapTC2D(CubeVector, ShadowMap_Parameters);\n"
3163 "#endif\n"
3164 "//     color.rgb = half3(tex2D(Texture_ShadowMap2D, float2(0.1,0.1)).rgb);\n"
3165 "//     color.rgb = half3(tex2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale).rgb);\n"
3166 "//     color.rgb = half3(shadowmaptc.xyz * float3(ShadowMap_TextureScale,1.0));\n"
3167 "//     color.r = half(texDepth2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale));\n"
3168 "//     color.rgb = half3(tex2D(Texture_ShadowMap2D, float2(0.1,0.1)).rgb);\n"
3169 "//     color.rgb = half3(tex2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale).rgb);\n"
3170 "//     color.rgb = half3(shadowmaptc.xyz * float3(ShadowMap_TextureScale,1.0));\n"
3171 "//     color.r = half(texDepth2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale));\n"
3172 "//     color.r = half(shadowmaptc.z - texDepth2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale));\n"
3173 "//     color.r = half(shadowmaptc.z);\n"
3174 "//     color.r = half(texDepth2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale));\n"
3175 "//     color.r = half(shadowmaptc.z);\n"
3176 "//     color.r = 1;\n"
3177 "//     color.rgb = abs(CubeVector);\n"
3178 "#endif\n"
3179 "//     color.rgb = half3(1,1,1);\n"
3180 "#endif // MODE_LIGHTSOURCE\n"
3181 "\n"
3182 "\n"
3183 "\n"
3184 "\n"
3185 "#ifdef MODE_LIGHTDIRECTION\n"
3186 "#define SHADING\n"
3187 "#ifdef USEDIFFUSE\n"
3188 "       half3 lightnormal = half3(normalize(LightVector));\n"
3189 "#endif\n"
3190 "#define lightcolor LightColor\n"
3191 "#endif // MODE_LIGHTDIRECTION\n"
3192 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
3193 "#define SHADING\n"
3194 "       // deluxemap lightmapping using light vectors in modelspace (q3map2 -light -deluxe)\n"
3195 "       half3 lightnormal_modelspace = half3(tex2D(Texture_Deluxemap, TexCoordLightmap).rgb) * 2.0 + half3(-1.0, -1.0, -1.0);\n"
3196 "       half3 lightcolor = half3(tex2D(Texture_Lightmap, TexCoordLightmap).rgb);\n"
3197 "       // convert modelspace light vector to tangentspace\n"
3198 "       half3 lightnormal;\n"
3199 "       lightnormal.x = dot(lightnormal_modelspace, half3(VectorS));\n"
3200 "       lightnormal.y = dot(lightnormal_modelspace, half3(VectorT));\n"
3201 "       lightnormal.z = dot(lightnormal_modelspace, half3(VectorR));\n"
3202 "       // calculate directional shading (and undoing the existing angle attenuation on the lightmap by the division)\n"
3203 "       // note that q3map2 is too stupid to calculate proper surface normals when q3map_nonplanar\n"
3204 "       // is used (the lightmap and deluxemap coords correspond to virtually random coordinates\n"
3205 "       // on that luxel, and NOT to its center, because recursive triangle subdivision is used\n"
3206 "       // to map the luxels to coordinates on the draw surfaces), which also causes\n"
3207 "       // deluxemaps to be wrong because light contributions from the wrong side of the surface\n"
3208 "       // are added up. To prevent divisions by zero or strong exaggerations, a max()\n"
3209 "       // nudge is done here at expense of some additional fps. This is ONLY needed for\n"
3210 "       // deluxemaps, tangentspace deluxemap avoid this problem by design.\n"
3211 "       lightcolor *= 1.0 / max(0.25, lightnormal.z);\n"
3212 "#endif // MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
3213 "#ifdef MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
3214 "#define SHADING\n"
3215 "       // deluxemap lightmapping using light vectors in tangentspace (hmap2 -light)\n"
3216 "       half3 lightnormal = half3(tex2D(Texture_Deluxemap, TexCoordLightmap).rgb) * 2.0 + half3(-1.0, -1.0, -1.0);\n"
3217 "       half3 lightcolor = half3(tex2D(Texture_Lightmap, TexCoordLightmap).rgb);\n"
3218 "#endif\n"
3219 "\n"
3220 "\n"
3221 "\n"
3222 "\n"
3223 "#ifdef MODE_FAKELIGHT\n"
3224 "#define SHADING\n"
3225 "half3 lightnormal = half3(normalize(EyeVector));\n"
3226 "half3 lightcolor = half3(1.0,1.0,1.0);\n"
3227 "#endif // MODE_FAKELIGHT\n"
3228 "\n"
3229 "\n"
3230 "\n"
3231 "\n"
3232 "#ifdef MODE_LIGHTMAP\n"
3233 "       color.rgb = diffusetex * (Color_Ambient + half3(tex2D(Texture_Lightmap, TexCoordLightmap).rgb) * Color_Diffuse);\n"
3234 "#endif // MODE_LIGHTMAP\n"
3235 "#ifdef MODE_VERTEXCOLOR\n"
3236 "       color.rgb = diffusetex * (Color_Ambient + half3(gl_FrontColor.rgb) * Color_Diffuse);\n"
3237 "#endif // MODE_VERTEXCOLOR\n"
3238 "#ifdef MODE_FLATCOLOR\n"
3239 "       color.rgb = diffusetex * Color_Ambient;\n"
3240 "#endif // MODE_FLATCOLOR\n"
3241 "\n"
3242 "\n"
3243 "\n"
3244 "\n"
3245 "#ifdef SHADING\n"
3246 "# ifdef USEDIFFUSE\n"
3247 "       half diffuse = half(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
3248 "#  ifdef USESPECULAR\n"
3249 "#   ifdef USEEXACTSPECULARMATH\n"
3250 "       half specular = half(pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a));\n"
3251 "#   else\n"
3252 "       half3 specularnormal = half3(normalize(lightnormal + half3(normalize(EyeVector))));\n"
3253 "       half specular = half(pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a));\n"
3254 "#   endif\n"
3255 "       color.rgb = diffusetex * Color_Ambient + (diffusetex * Color_Diffuse * diffuse + glosstex.rgb * Color_Specular * specular) * lightcolor;\n"
3256 "#  else\n"
3257 "       color.rgb = diffusetex * (Color_Ambient + Color_Diffuse * diffuse * lightcolor);\n"
3258 "#  endif\n"
3259 "# else\n"
3260 "       color.rgb = diffusetex * Color_Ambient;\n"
3261 "# endif\n"
3262 "#endif\n"
3263 "\n"
3264 "#ifdef USESHADOWMAPORTHO\n"
3265 "       color.rgb *= half(ShadowMapCompare(ShadowMapTC, Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale));\n"
3266 "#endif\n"
3267 "\n"
3268 "#ifdef USEDEFERREDLIGHTMAP\n"
3269 "       float2 ScreenTexCoord = Pixel * PixelToScreenTexCoord;\n"
3270 "       color.rgb += diffusetex * half3(tex2D(Texture_ScreenDiffuse, ScreenTexCoord).rgb) * DeferredMod_Diffuse;\n"
3271 "       color.rgb += glosstex.rgb * half3(tex2D(Texture_ScreenSpecular, ScreenTexCoord).rgb) * DeferredMod_Specular;\n"
3272 "//     color.rgb = half3(tex2D(Texture_ScreenDepth, ScreenTexCoord).rgb);\n"
3273 "//     color.r = half(texDepth2D(Texture_ScreenDepth, ScreenTexCoord)) * 1.0;\n"
3274 "#endif\n"
3275 "\n"
3276 "#ifdef USEGLOW\n"
3277 "#ifdef USEVERTEXTEXTUREBLEND\n"
3278 "       color.rgb += half3(lerp(tex2D(Texture_SecondaryGlow, TexCoord2).rgb, tex2D(Texture_Glow, TexCoord).rgb, terrainblend)) * Color_Glow;\n"
3279 "#else\n"
3280 "       color.rgb += half3(tex2D(Texture_Glow, TexCoord).rgb) * Color_Glow;\n"
3281 "#endif\n"
3282 "#endif\n"
3283 "\n"
3284 "#ifdef USEFOG\n"
3285 "       color.rgb = FogVertex(color.rgb, FogColor, EyeVectorModelSpaceFogPlaneVertexDist.xyz, EyeVectorModelSpaceFogPlaneVertexDist.w, FogRangeRecip, FogPlaneViewDist, FogHeightFade, Texture_FogMask, Texture_FogHeightTexture);\n"
3286 "#endif\n"
3287 "\n"
3288 "       // 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"
3289 "#ifdef USEREFLECTION\n"
3290 "       float4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
3291 "       //float4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(half3(tex2D(Texture_Normal, TexCoord).rgb) - half3(0.5,0.5,0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
3292 "       float2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW.zw + ScreenCenterRefractReflect.zw;\n"
3293 "       float2 ScreenTexCoord = SafeScreenTexCoord + float3(normalize(half3(tex2D(Texture_Normal, TexCoord).rgb) - half3(0.5,0.5,0.5))).xy * DistortScaleRefractReflect.zw;\n"
3294 "       // FIXME temporary hack to detect the case that the reflection\n"
3295 "       // gets blackened at edges due to leaving the area that contains actual\n"
3296 "       // content.\n"
3297 "       // Remove this 'ack once we have a better way to stop this thing from\n"
3298 "       // 'appening.\n"
3299 "       float f = min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(0.01, 0.01)).rgb) / 0.05);\n"
3300 "       f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(0.01, -0.01)).rgb) / 0.05);\n"
3301 "       f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(-0.01, 0.01)).rgb) / 0.05);\n"
3302 "       f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(-0.01, -0.01)).rgb) / 0.05);\n"
3303 "       ScreenTexCoord = lerp(SafeScreenTexCoord, ScreenTexCoord, f);\n"
3304 "       color.rgb = lerp(color.rgb, half3(tex2D(Texture_Reflection, ScreenTexCoord).rgb) * ReflectColor.rgb, ReflectColor.a);\n"
3305 "#endif\n"
3306 "\n"
3307 "       gl_FragColor = float4(color);\n"
3308 "}\n"
3309 "#endif // FRAGMENT_SHADER\n"
3310 "\n"
3311 "#endif // !MODE_DEFERREDLIGHTSOURCE\n"
3312 "#endif // !MODE_DEFERREDGEOMETRY\n"
3313 "#endif // !MODE_WATER\n"
3314 "#endif // !MODE_REFRACTION\n"
3315 "#endif // !MODE_BLOOMBLUR\n"
3316 "#endif // !MODE_GENERIC\n"
3317 "#endif // !MODE_POSTPROCESS\n"
3318 "#endif // !MODE_SHOWDEPTH\n"
3319 "#endif // !MODE_DEPTH_OR_SHADOW\n"
3320 ;
3321
3322 char *glslshaderstring = NULL;
3323 char *cgshaderstring = NULL;
3324 char *hlslshaderstring = NULL;
3325
3326 //=======================================================================================================================================================
3327
3328 typedef struct shaderpermutationinfo_s
3329 {
3330         const char *pretext;
3331         const char *name;
3332 }
3333 shaderpermutationinfo_t;
3334
3335 typedef struct shadermodeinfo_s
3336 {
3337         const char *vertexfilename;
3338         const char *geometryfilename;
3339         const char *fragmentfilename;
3340         const char *pretext;
3341         const char *name;
3342 }
3343 shadermodeinfo_t;
3344
3345 typedef enum shaderpermutation_e
3346 {
3347         SHADERPERMUTATION_DIFFUSE = 1<<0, ///< (lightsource) whether to use directional shading
3348         SHADERPERMUTATION_VERTEXTEXTUREBLEND = 1<<1, ///< indicates this is a two-layer material blend based on vertex alpha (q3bsp)
3349         SHADERPERMUTATION_VIEWTINT = 1<<2, ///< view tint (postprocessing only), use vertex colors (generic only)
3350         SHADERPERMUTATION_COLORMAPPING = 1<<3, ///< indicates this is a colormapped skin
3351         SHADERPERMUTATION_SATURATION = 1<<4, ///< saturation (postprocessing only)
3352         SHADERPERMUTATION_FOGINSIDE = 1<<5, ///< tint the color by fog color or black if using additive blend mode
3353         SHADERPERMUTATION_FOGOUTSIDE = 1<<6, ///< tint the color by fog color or black if using additive blend mode
3354         SHADERPERMUTATION_FOGHEIGHTTEXTURE = 1<<7, ///< fog color and density determined by texture mapped on vertical axis
3355         SHADERPERMUTATION_GAMMARAMPS = 1<<8, ///< gamma (postprocessing only)
3356         SHADERPERMUTATION_CUBEFILTER = 1<<9, ///< (lightsource) use cubemap light filter
3357         SHADERPERMUTATION_GLOW = 1<<10, ///< (lightmap) blend in an additive glow texture
3358         SHADERPERMUTATION_BLOOM = 1<<11, ///< bloom (postprocessing only)
3359         SHADERPERMUTATION_SPECULAR = 1<<12, ///< (lightsource or deluxemapping) render specular effects
3360         SHADERPERMUTATION_POSTPROCESSING = 1<<13, ///< user defined postprocessing (postprocessing only)
3361         SHADERPERMUTATION_REFLECTION = 1<<14, ///< normalmap-perturbed reflection of the scene infront of the surface, preformed as an overlay on the surface
3362         SHADERPERMUTATION_OFFSETMAPPING = 1<<15, ///< adjust texcoords to roughly simulate a displacement mapped surface
3363         SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING = 1<<16, ///< adjust texcoords to accurately simulate a displacement mapped surface (requires OFFSETMAPPING to also be set!)
3364         SHADERPERMUTATION_SHADOWMAP2D = 1<<17, ///< (lightsource) use shadowmap texture as light filter
3365         SHADERPERMUTATION_SHADOWMAPPCF = 1<<18, ///< (lightsource) use percentage closer filtering on shadowmap test results
3366         SHADERPERMUTATION_SHADOWMAPPCF2 = 1<<19, ///< (lightsource) use higher quality percentage closer filtering on shadowmap test results
3367         SHADERPERMUTATION_SHADOWSAMPLER = 1<<20, ///< (lightsource) use hardware shadowmap test
3368         SHADERPERMUTATION_SHADOWMAPVSDCT = 1<<21, ///< (lightsource) use virtual shadow depth cube texture for shadowmap indexing
3369         SHADERPERMUTATION_SHADOWMAPORTHO = 1<<22, //< (lightsource) use orthographic shadowmap projection
3370         SHADERPERMUTATION_DEFERREDLIGHTMAP = 1<<23, ///< (lightmap) read Texture_ScreenDiffuse/Specular textures and add them on top of lightmapping
3371         SHADERPERMUTATION_ALPHAKILL = 1<<24, ///< (deferredgeometry) discard pixel if diffuse texture alpha below 0.5
3372         SHADERPERMUTATION_REFLECTCUBE = 1<<25, ///< fake reflections using global cubemap (not HDRI light probe)
3373         SHADERPERMUTATION_NORMALMAPSCROLLBLEND = 1<<26, // (water) counter-direction normalmaps scrolling
3374         SHADERPERMUTATION_LIMIT = 1<<27, ///< size of permutations array
3375         SHADERPERMUTATION_COUNT = 27 ///< size of shaderpermutationinfo array
3376 }
3377 shaderpermutation_t;
3378
3379 // NOTE: MUST MATCH ORDER OF SHADERPERMUTATION_* DEFINES!
3380 shaderpermutationinfo_t shaderpermutationinfo[SHADERPERMUTATION_COUNT] =
3381 {
3382         {"#define USEDIFFUSE\n", " diffuse"},
3383         {"#define USEVERTEXTEXTUREBLEND\n", " vertextextureblend"},
3384         {"#define USEVIEWTINT\n", " viewtint"},
3385         {"#define USECOLORMAPPING\n", " colormapping"},
3386         {"#define USESATURATION\n", " saturation"},
3387         {"#define USEFOGINSIDE\n", " foginside"},
3388         {"#define USEFOGOUTSIDE\n", " fogoutside"},
3389         {"#define USEFOGHEIGHTTEXTURE\n", " fogheighttexture"},
3390         {"#define USEGAMMARAMPS\n", " gammaramps"},
3391         {"#define USECUBEFILTER\n", " cubefilter"},
3392         {"#define USEGLOW\n", " glow"},
3393         {"#define USEBLOOM\n", " bloom"},
3394         {"#define USESPECULAR\n", " specular"},
3395         {"#define USEPOSTPROCESSING\n", " postprocessing"},
3396         {"#define USEREFLECTION\n", " reflection"},
3397         {"#define USEOFFSETMAPPING\n", " offsetmapping"},
3398         {"#define USEOFFSETMAPPING_RELIEFMAPPING\n", " reliefmapping"},
3399         {"#define USESHADOWMAP2D\n", " shadowmap2d"},
3400         {"#define USESHADOWMAPPCF 1\n", " shadowmappcf"},
3401         {"#define USESHADOWMAPPCF 2\n", " shadowmappcf2"},
3402         {"#define USESHADOWSAMPLER\n", " shadowsampler"},
3403         {"#define USESHADOWMAPVSDCT\n", " shadowmapvsdct"},
3404         {"#define USESHADOWMAPORTHO\n", " shadowmaportho"},
3405         {"#define USEDEFERREDLIGHTMAP\n", " deferredlightmap"},
3406         {"#define USEALPHAKILL\n", " alphakill"},
3407         {"#define USEREFLECTCUBE\n", " reflectcube"},
3408         {"#define USENORMALMAPSCROLLBLEND\n", " normalmapscrollblend"},
3409 };
3410
3411 // this enum selects which of the glslshadermodeinfo entries should be used
3412 typedef enum shadermode_e
3413 {
3414         SHADERMODE_GENERIC, ///< (particles/HUD/etc) vertex color, optionally multiplied by one texture
3415         SHADERMODE_POSTPROCESS, ///< postprocessing shader (r_glsl_postprocess)
3416         SHADERMODE_DEPTH_OR_SHADOW, ///< (depthfirst/shadows) vertex shader only
3417         SHADERMODE_FLATCOLOR, ///< (lightmap) modulate texture by uniform color (q1bsp, q3bsp)
3418         SHADERMODE_VERTEXCOLOR, ///< (lightmap) modulate texture by vertex colors (q3bsp)
3419         SHADERMODE_LIGHTMAP, ///< (lightmap) modulate texture by lightmap texture (q1bsp, q3bsp)
3420         SHADERMODE_FAKELIGHT, ///< (fakelight) modulate texture by "fake" lighting (no lightmaps, no nothing)
3421         SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE, ///< (lightmap) use directional pixel shading from texture containing modelspace light directions (q3bsp deluxemap)
3422         SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE, ///< (lightmap) use directional pixel shading from texture containing tangentspace light directions (q1bsp deluxemap)
3423         SHADERMODE_LIGHTDIRECTION, ///< (lightmap) use directional pixel shading from fixed light direction (q3bsp)
3424         SHADERMODE_LIGHTSOURCE, ///< (lightsource) use directional pixel shading from light source (rtlight)
3425         SHADERMODE_REFRACTION, ///< refract background (the material is rendered normally after this pass)
3426         SHADERMODE_WATER, ///< refract background and reflection (the material is rendered normally after this pass)
3427         SHADERMODE_SHOWDEPTH, ///< (debugging) renders depth as color
3428         SHADERMODE_DEFERREDGEOMETRY, ///< (deferred) render material properties to screenspace geometry buffers
3429         SHADERMODE_DEFERREDLIGHTSOURCE, ///< (deferred) use directional pixel shading from light source (rtlight) on screenspace geometry buffers
3430         SHADERMODE_COUNT
3431 }
3432 shadermode_t;
3433
3434 // NOTE: MUST MATCH ORDER OF SHADERMODE_* ENUMS!
3435 shadermodeinfo_t glslshadermodeinfo[SHADERMODE_COUNT] =
3436 {
3437         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_GENERIC\n", " generic"},
3438         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_POSTPROCESS\n", " postprocess"},
3439         {"glsl/default.glsl", NULL, NULL               , "#define MODE_DEPTH_OR_SHADOW\n", " depth/shadow"},
3440         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_FLATCOLOR\n", " flatcolor"},
3441         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_VERTEXCOLOR\n", " vertexcolor"},
3442         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTMAP\n", " lightmap"},
3443         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_FAKELIGHT\n", " fakelight"},
3444         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
3445         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
3446         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTION\n", " lightdirection"},
3447         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTSOURCE\n", " lightsource"},
3448         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_REFRACTION\n", " refraction"},
3449         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_WATER\n", " water"},
3450         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_SHOWDEPTH\n", " showdepth"},
3451         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_DEFERREDGEOMETRY\n", " deferredgeometry"},
3452         {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_DEFERREDLIGHTSOURCE\n", " deferredlightsource"},
3453 };
3454
3455 #ifdef SUPPORTCG
3456 shadermodeinfo_t cgshadermodeinfo[SHADERMODE_COUNT] =
3457 {
3458         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_GENERIC\n", " generic"},
3459         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_POSTPROCESS\n", " postprocess"},
3460         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_DEPTH_OR_SHADOW\n", " depth/shadow"},
3461         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_FLATCOLOR\n", " flatcolor"},
3462         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_VERTEXCOLOR\n", " vertexcolor"},
3463         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTMAP\n", " lightmap"},
3464         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_FAKELIGHT\n", " fakelight"},
3465         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
3466         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
3467         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTDIRECTION\n", " lightdirection"},
3468         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTSOURCE\n", " lightsource"},
3469         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_REFRACTION\n", " refraction"},
3470         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_WATER\n", " water"},
3471         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_SHOWDEPTH\n", " showdepth"},
3472         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_DEFERREDGEOMETRY\n", " deferredgeometry"},
3473         {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_DEFERREDLIGHTSOURCE\n", " deferredlightsource"},
3474 };
3475 #endif
3476
3477 #ifdef SUPPORTD3D
3478 shadermodeinfo_t hlslshadermodeinfo[SHADERMODE_COUNT] =
3479 {
3480         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_GENERIC\n", " generic"},
3481         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_POSTPROCESS\n", " postprocess"},
3482         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_DEPTH_OR_SHADOW\n", " depth/shadow"},
3483         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_FLATCOLOR\n", " flatcolor"},
3484         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_VERTEXCOLOR\n", " vertexcolor"},
3485         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTMAP\n", " lightmap"},
3486         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_FAKELIGHT\n", " fakelight"},
3487         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
3488         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
3489         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTDIRECTION\n", " lightdirection"},
3490         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTSOURCE\n", " lightsource"},
3491         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_REFRACTION\n", " refraction"},
3492         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_WATER\n", " water"},
3493         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_SHOWDEPTH\n", " showdepth"},
3494         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_DEFERREDGEOMETRY\n", " deferredgeometry"},
3495         {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_DEFERREDLIGHTSOURCE\n", " deferredlightsource"},
3496 };
3497 #endif
3498
3499 struct r_glsl_permutation_s;
3500 typedef struct r_glsl_permutation_s
3501 {
3502         /// hash lookup data
3503         struct r_glsl_permutation_s *hashnext;
3504         unsigned int mode;
3505         unsigned int permutation;
3506
3507         /// indicates if we have tried compiling this permutation already
3508         qboolean compiled;
3509         /// 0 if compilation failed
3510         int program;
3511         /// locations of detected uniforms in program object, or -1 if not found
3512         int loc_Texture_First;
3513         int loc_Texture_Second;
3514         int loc_Texture_GammaRamps;
3515         int loc_Texture_Normal;
3516         int loc_Texture_Color;
3517         int loc_Texture_Gloss;
3518         int loc_Texture_Glow;
3519         int loc_Texture_SecondaryNormal;
3520         int loc_Texture_SecondaryColor;
3521         int loc_Texture_SecondaryGloss;
3522         int loc_Texture_SecondaryGlow;
3523         int loc_Texture_Pants;
3524         int loc_Texture_Shirt;
3525         int loc_Texture_FogHeightTexture;
3526         int loc_Texture_FogMask;
3527         int loc_Texture_Lightmap;
3528         int loc_Texture_Deluxemap;
3529         int loc_Texture_Attenuation;
3530         int loc_Texture_Cube;
3531         int loc_Texture_Refraction;
3532         int loc_Texture_Reflection;
3533         int loc_Texture_ShadowMap2D;
3534         int loc_Texture_CubeProjection;
3535         int loc_Texture_ScreenDepth;
3536         int loc_Texture_ScreenNormalMap;
3537         int loc_Texture_ScreenDiffuse;
3538         int loc_Texture_ScreenSpecular;
3539         int loc_Texture_ReflectMask;
3540         int loc_Texture_ReflectCube;
3541         int loc_Alpha;
3542         int loc_BloomBlur_Parameters;
3543         int loc_ClientTime;
3544         int loc_Color_Ambient;
3545         int loc_Color_Diffuse;
3546         int loc_Color_Specular;
3547         int loc_Color_Glow;
3548         int loc_Color_Pants;
3549         int loc_Color_Shirt;
3550         int loc_DeferredColor_Ambient;
3551         int loc_DeferredColor_Diffuse;
3552         int loc_DeferredColor_Specular;
3553         int loc_DeferredMod_Diffuse;
3554         int loc_DeferredMod_Specular;
3555         int loc_DistortScaleRefractReflect;
3556         int loc_EyePosition;
3557         int loc_FogColor;
3558         int loc_FogHeightFade;
3559         int loc_FogPlane;
3560         int loc_FogPlaneViewDist;
3561         int loc_FogRangeRecip;
3562         int loc_LightColor;
3563         int loc_LightDir;
3564         int loc_LightPosition;
3565         int loc_OffsetMapping_Scale;
3566         int loc_PixelSize;
3567         int loc_ReflectColor;
3568         int loc_ReflectFactor;
3569         int loc_ReflectOffset;
3570         int loc_RefractColor;
3571         int loc_Saturation;
3572         int loc_ScreenCenterRefractReflect;
3573         int loc_ScreenScaleRefractReflect;
3574         int loc_ScreenToDepth;
3575         int loc_ShadowMap_Parameters;
3576         int loc_ShadowMap_TextureScale;
3577         int loc_SpecularPower;
3578         int loc_UserVec1;
3579         int loc_UserVec2;
3580         int loc_UserVec3;
3581         int loc_UserVec4;
3582         int loc_ViewTintColor;
3583         int loc_ViewToLight;
3584         int loc_ModelToLight;
3585         int loc_TexMatrix;
3586         int loc_BackgroundTexMatrix;
3587         int loc_ModelViewProjectionMatrix;
3588         int loc_ModelViewMatrix;
3589         int loc_PixelToScreenTexCoord;
3590         int loc_ModelToReflectCube;
3591         int loc_ShadowMapMatrix;
3592         int loc_BloomColorSubtract;
3593         int loc_NormalmapScrollBlend;
3594 }
3595 r_glsl_permutation_t;
3596
3597 #define SHADERPERMUTATION_HASHSIZE 256
3598
3599
3600 // non-degradable "lightweight" shader parameters to keep the permutations simpler
3601 // these can NOT degrade! only use for simple stuff
3602 enum
3603 {
3604         SHADERSTATICPARM_SATURATION_REDCOMPENSATE = 0, ///< red compensation filter for saturation
3605         SHADERSTATICPARM_EXACTSPECULARMATH = 1, ///< (lightsource or deluxemapping) use exact reflection map for specular effects, as opposed to the usual OpenGL approximation
3606         SHADERSTATICPARM_POSTPROCESS_USERVEC1 = 2, ///< postprocess uservec1 is enabled
3607         SHADERSTATICPARM_POSTPROCESS_USERVEC2 = 3, ///< postprocess uservec2 is enabled
3608         SHADERSTATICPARM_POSTPROCESS_USERVEC3 = 4, ///< postprocess uservec3 is enabled
3609         SHADERSTATICPARM_POSTPROCESS_USERVEC4 = 5  ///< postprocess uservec4 is enabled
3610 };
3611 #define SHADERSTATICPARMS_COUNT 6
3612
3613 static const char *shaderstaticparmstrings_list[SHADERSTATICPARMS_COUNT];
3614 static int shaderstaticparms_count = 0;
3615
3616 static unsigned int r_compileshader_staticparms[(SHADERSTATICPARMS_COUNT + 0x1F) >> 5] = {0};
3617 #define R_COMPILESHADER_STATICPARM_ENABLE(p) r_compileshader_staticparms[(p) >> 5] |= (1 << ((p) & 0x1F))
3618 qboolean R_CompileShader_CheckStaticParms(void)
3619 {
3620         static int r_compileshader_staticparms_save[1];
3621         memcpy(r_compileshader_staticparms_save, r_compileshader_staticparms, sizeof(r_compileshader_staticparms));
3622         memset(r_compileshader_staticparms, 0, sizeof(r_compileshader_staticparms));
3623
3624         // detect all
3625         if (r_glsl_saturation_redcompensate.integer)
3626                 R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_SATURATION_REDCOMPENSATE);
3627         if (r_shadow_glossexact.integer)
3628                 R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_EXACTSPECULARMATH);
3629         if (r_glsl_postprocess.integer)
3630         {
3631                 if (r_glsl_postprocess_uservec1_enable.integer)
3632                         R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_POSTPROCESS_USERVEC1);
3633                 if (r_glsl_postprocess_uservec2_enable.integer)
3634                         R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_POSTPROCESS_USERVEC2);
3635                 if (r_glsl_postprocess_uservec3_enable.integer)
3636                         R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_POSTPROCESS_USERVEC3);
3637                 if (r_glsl_postprocess_uservec4_enable.integer)
3638                         R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_POSTPROCESS_USERVEC4);
3639         }
3640         return memcmp(r_compileshader_staticparms, r_compileshader_staticparms_save, sizeof(r_compileshader_staticparms)) != 0;
3641 }
3642
3643 #define R_COMPILESHADER_STATICPARM_EMIT(p, n) \
3644         if(r_compileshader_staticparms[(p) >> 5] & (1 << ((p) & 0x1F))) \
3645                 shaderstaticparmstrings_list[shaderstaticparms_count++] = "#define " n "\n"; \
3646         else \
3647                 shaderstaticparmstrings_list[shaderstaticparms_count++] = "\n"
3648 void R_CompileShader_AddStaticParms(unsigned int mode, unsigned int permutation)
3649 {
3650         shaderstaticparms_count = 0;
3651
3652         // emit all
3653         R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_SATURATION_REDCOMPENSATE, "SATURATION_REDCOMPENSATE");
3654         R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_EXACTSPECULARMATH, "USEEXACTSPECULARMATH");
3655         R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_POSTPROCESS_USERVEC1, "USERVEC1");
3656         R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_POSTPROCESS_USERVEC2, "USERVEC2");
3657         R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_POSTPROCESS_USERVEC3, "USERVEC3");
3658         R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_POSTPROCESS_USERVEC4, "USERVEC4");
3659 }
3660
3661 /// information about each possible shader permutation
3662 r_glsl_permutation_t *r_glsl_permutationhash[SHADERMODE_COUNT][SHADERPERMUTATION_HASHSIZE];
3663 /// currently selected permutation
3664 r_glsl_permutation_t *r_glsl_permutation;
3665 /// storage for permutations linked in the hash table
3666 memexpandablearray_t r_glsl_permutationarray;
3667
3668 static r_glsl_permutation_t *R_GLSL_FindPermutation(unsigned int mode, unsigned int permutation)
3669 {
3670         //unsigned int hashdepth = 0;
3671         unsigned int hashindex = (permutation * 0x1021) & (SHADERPERMUTATION_HASHSIZE - 1);
3672         r_glsl_permutation_t *p;
3673         for (p = r_glsl_permutationhash[mode][hashindex];p;p = p->hashnext)
3674         {
3675                 if (p->mode == mode && p->permutation == permutation)
3676                 {
3677                         //if (hashdepth > 10)
3678                         //      Con_Printf("R_GLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
3679                         return p;
3680                 }
3681                 //hashdepth++;
3682         }
3683         p = (r_glsl_permutation_t*)Mem_ExpandableArray_AllocRecord(&r_glsl_permutationarray);
3684         p->mode = mode;
3685         p->permutation = permutation;
3686         p->hashnext = r_glsl_permutationhash[mode][hashindex];
3687         r_glsl_permutationhash[mode][hashindex] = p;
3688         //if (hashdepth > 10)
3689         //      Con_Printf("R_GLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
3690         return p;
3691 }
3692
3693 static char *R_GLSL_GetText(const char *filename, qboolean printfromdisknotice)
3694 {
3695         char *shaderstring;
3696         if (!filename || !filename[0])
3697                 return NULL;
3698         if (!strcmp(filename, "glsl/default.glsl"))
3699         {
3700                 if (!glslshaderstring)
3701                 {
3702                         glslshaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
3703                         if (glslshaderstring)
3704                                 Con_DPrintf("Loading shaders from file %s...\n", filename);
3705                         else
3706                                 glslshaderstring = (char *)builtinshaderstring;
3707                 }
3708                 shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(glslshaderstring) + 1);
3709                 memcpy(shaderstring, glslshaderstring, strlen(glslshaderstring) + 1);
3710                 return shaderstring;
3711         }
3712         shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
3713         if (shaderstring)
3714         {
3715                 if (printfromdisknotice)
3716                         Con_DPrintf("from disk %s... ", filename);
3717                 return shaderstring;
3718         }
3719         return shaderstring;
3720 }
3721
3722 static void R_GLSL_CompilePermutation(r_glsl_permutation_t *p, unsigned int mode, unsigned int permutation)
3723 {
3724         int i;
3725         shadermodeinfo_t *modeinfo = glslshadermodeinfo + mode;
3726         char *vertexstring, *geometrystring, *fragmentstring;
3727         char permutationname[256];
3728         int vertstrings_count = 0;
3729         int geomstrings_count = 0;
3730         int fragstrings_count = 0;
3731         const char *vertstrings_list[32+3+SHADERSTATICPARMS_COUNT+1];
3732         const char *geomstrings_list[32+3+SHADERSTATICPARMS_COUNT+1];
3733         const char *fragstrings_list[32+3+SHADERSTATICPARMS_COUNT+1];
3734
3735         if (p->compiled)
3736                 return;
3737         p->compiled = true;
3738         p->program = 0;
3739
3740         permutationname[0] = 0;
3741         vertexstring   = R_GLSL_GetText(modeinfo->vertexfilename, true);
3742         geometrystring = R_GLSL_GetText(modeinfo->geometryfilename, false);
3743         fragmentstring = R_GLSL_GetText(modeinfo->fragmentfilename, false);
3744
3745         strlcat(permutationname, modeinfo->vertexfilename, sizeof(permutationname));
3746
3747         // the first pretext is which type of shader to compile as
3748         // (later these will all be bound together as a program object)
3749         vertstrings_list[vertstrings_count++] = "#define VERTEX_SHADER\n";
3750         geomstrings_list[geomstrings_count++] = "#define GEOMETRY_SHADER\n";
3751         fragstrings_list[fragstrings_count++] = "#define FRAGMENT_SHADER\n";
3752
3753         // the second pretext is the mode (for example a light source)
3754         vertstrings_list[vertstrings_count++] = modeinfo->pretext;
3755         geomstrings_list[geomstrings_count++] = modeinfo->pretext;
3756         fragstrings_list[fragstrings_count++] = modeinfo->pretext;
3757         strlcat(permutationname, modeinfo->name, sizeof(permutationname));
3758
3759         // now add all the permutation pretexts
3760         for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
3761         {
3762                 if (permutation & (1<<i))
3763                 {
3764                         vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i].pretext;
3765                         geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i].pretext;
3766                         fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i].pretext;
3767                         strlcat(permutationname, shaderpermutationinfo[i].name, sizeof(permutationname));
3768                 }
3769                 else
3770                 {
3771                         // keep line numbers correct
3772                         vertstrings_list[vertstrings_count++] = "\n";
3773                         geomstrings_list[geomstrings_count++] = "\n";
3774                         fragstrings_list[fragstrings_count++] = "\n";
3775                 }
3776         }
3777
3778         // add static parms
3779         R_CompileShader_AddStaticParms(mode, permutation);
3780         memcpy((char *)(vertstrings_list + vertstrings_count), shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
3781         vertstrings_count += shaderstaticparms_count;
3782         memcpy((char *)(geomstrings_list + geomstrings_count), shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
3783         geomstrings_count += shaderstaticparms_count;
3784         memcpy((char *)(fragstrings_list + fragstrings_count), shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
3785         fragstrings_count += shaderstaticparms_count;
3786
3787         // now append the shader text itself
3788         vertstrings_list[vertstrings_count++] = vertexstring;
3789         geomstrings_list[geomstrings_count++] = geometrystring;
3790         fragstrings_list[fragstrings_count++] = fragmentstring;
3791
3792         // if any sources were NULL, clear the respective list
3793         if (!vertexstring)
3794                 vertstrings_count = 0;
3795         if (!geometrystring)
3796                 geomstrings_count = 0;
3797         if (!fragmentstring)
3798                 fragstrings_count = 0;
3799
3800         // compile the shader program
3801         if (vertstrings_count + geomstrings_count + fragstrings_count)
3802                 p->program = GL_Backend_CompileProgram(vertstrings_count, vertstrings_list, geomstrings_count, geomstrings_list, fragstrings_count, fragstrings_list);
3803         if (p->program)
3804         {
3805                 CHECKGLERROR
3806                 qglUseProgramObjectARB(p->program);CHECKGLERROR
3807                 // look up all the uniform variable names we care about, so we don't
3808                 // have to look them up every time we set them
3809
3810                 p->loc_Texture_First              = qglGetUniformLocationARB(p->program, "Texture_First");
3811                 p->loc_Texture_Second             = qglGetUniformLocationARB(p->program, "Texture_Second");
3812                 p->loc_Texture_GammaRamps         = qglGetUniformLocationARB(p->program, "Texture_GammaRamps");
3813                 p->loc_Texture_Normal             = qglGetUniformLocationARB(p->program, "Texture_Normal");
3814                 p->loc_Texture_Color              = qglGetUniformLocationARB(p->program, "Texture_Color");
3815                 p->loc_Texture_Gloss              = qglGetUniformLocationARB(p->program, "Texture_Gloss");
3816                 p->loc_Texture_Glow               = qglGetUniformLocationARB(p->program, "Texture_Glow");
3817                 p->loc_Texture_SecondaryNormal    = qglGetUniformLocationARB(p->program, "Texture_SecondaryNormal");
3818                 p->loc_Texture_SecondaryColor     = qglGetUniformLocationARB(p->program, "Texture_SecondaryColor");
3819                 p->loc_Texture_SecondaryGloss     = qglGetUniformLocationARB(p->program, "Texture_SecondaryGloss");
3820                 p->loc_Texture_SecondaryGlow      = qglGetUniformLocationARB(p->program, "Texture_SecondaryGlow");
3821                 p->loc_Texture_Pants              = qglGetUniformLocationARB(p->program, "Texture_Pants");
3822                 p->loc_Texture_Shirt              = qglGetUniformLocationARB(p->program, "Texture_Shirt");
3823                 p->loc_Texture_FogHeightTexture   = qglGetUniformLocationARB(p->program, "Texture_FogHeightTexture");
3824                 p->loc_Texture_FogMask            = qglGetUniformLocationARB(p->program, "Texture_FogMask");
3825                 p->loc_Texture_Lightmap           = qglGetUniformLocationARB(p->program, "Texture_Lightmap");
3826                 p->loc_Texture_Deluxemap          = qglGetUniformLocationARB(p->program, "Texture_Deluxemap");
3827                 p->loc_Texture_Attenuation        = qglGetUniformLocationARB(p->program, "Texture_Attenuation");
3828                 p->loc_Texture_Cube               = qglGetUniformLocationARB(p->program, "Texture_Cube");
3829                 p->loc_Texture_Refraction         = qglGetUniformLocationARB(p->program, "Texture_Refraction");
3830                 p->loc_Texture_Reflection         = qglGetUniformLocationARB(p->program, "Texture_Reflection");
3831                 p->loc_Texture_ShadowMap2D        = qglGetUniformLocationARB(p->program, "Texture_ShadowMap2D");
3832                 p->loc_Texture_CubeProjection     = qglGetUniformLocationARB(p->program, "Texture_CubeProjection");
3833                 p->loc_Texture_ScreenDepth        = qglGetUniformLocationARB(p->program, "Texture_ScreenDepth");
3834                 p->loc_Texture_ScreenNormalMap    = qglGetUniformLocationARB(p->program, "Texture_ScreenNormalMap");
3835                 p->loc_Texture_ScreenDiffuse      = qglGetUniformLocationARB(p->program, "Texture_ScreenDiffuse");
3836                 p->loc_Texture_ScreenSpecular     = qglGetUniformLocationARB(p->program, "Texture_ScreenSpecular");
3837                 p->loc_Texture_ReflectMask        = qglGetUniformLocationARB(p->program, "Texture_ReflectMask");
3838                 p->loc_Texture_ReflectCube        = qglGetUniformLocationARB(p->program, "Texture_ReflectCube");
3839                 p->loc_Alpha                      = qglGetUniformLocationARB(p->program, "Alpha");
3840                 p->loc_BloomBlur_Parameters       = qglGetUniformLocationARB(p->program, "BloomBlur_Parameters");
3841                 p->loc_ClientTime                 = qglGetUniformLocationARB(p->program, "ClientTime");
3842                 p->loc_Color_Ambient              = qglGetUniformLocationARB(p->program, "Color_Ambient");
3843                 p->loc_Color_Diffuse              = qglGetUniformLocationARB(p->program, "Color_Diffuse");
3844                 p->loc_Color_Specular             = qglGetUniformLocationARB(p->program, "Color_Specular");
3845                 p->loc_Color_Glow                 = qglGetUniformLocationARB(p->program, "Color_Glow");
3846                 p->loc_Color_Pants                = qglGetUniformLocationARB(p->program, "Color_Pants");
3847                 p->loc_Color_Shirt                = qglGetUniformLocationARB(p->program, "Color_Shirt");
3848                 p->loc_DeferredColor_Ambient      = qglGetUniformLocationARB(p->program, "DeferredColor_Ambient");
3849                 p->loc_DeferredColor_Diffuse      = qglGetUniformLocationARB(p->program, "DeferredColor_Diffuse");
3850                 p->loc_DeferredColor_Specular     = qglGetUniformLocationARB(p->program, "DeferredColor_Specular");
3851                 p->loc_DeferredMod_Diffuse        = qglGetUniformLocationARB(p->program, "DeferredMod_Diffuse");
3852                 p->loc_DeferredMod_Specular       = qglGetUniformLocationARB(p->program, "DeferredMod_Specular");
3853                 p->loc_DistortScaleRefractReflect = qglGetUniformLocationARB(p->program, "DistortScaleRefractReflect");
3854                 p->loc_EyePosition                = qglGetUniformLocationARB(p->program, "EyePosition");
3855                 p->loc_FogColor                   = qglGetUniformLocationARB(p->program, "FogColor");
3856                 p->loc_FogHeightFade              = qglGetUniformLocationARB(p->program, "FogHeightFade");
3857                 p->loc_FogPlane                   = qglGetUniformLocationARB(p->program, "FogPlane");
3858                 p->loc_FogPlaneViewDist           = qglGetUniformLocationARB(p->program, "FogPlaneViewDist");
3859                 p->loc_FogRangeRecip              = qglGetUniformLocationARB(p->program, "FogRangeRecip");
3860                 p->loc_LightColor                 = qglGetUniformLocationARB(p->program, "LightColor");
3861                 p->loc_LightDir                   = qglGetUniformLocationARB(p->program, "LightDir");
3862                 p->loc_LightPosition              = qglGetUniformLocationARB(p->program, "LightPosition");
3863                 p->loc_OffsetMapping_Scale        = qglGetUniformLocationARB(p->program, "OffsetMapping_Scale");
3864                 p->loc_PixelSize                  = qglGetUniformLocationARB(p->program, "PixelSize");
3865                 p->loc_ReflectColor               = qglGetUniformLocationARB(p->program, "ReflectColor");
3866                 p->loc_ReflectFactor              = qglGetUniformLocationARB(p->program, "ReflectFactor");
3867                 p->loc_ReflectOffset              = qglGetUniformLocationARB(p->program, "ReflectOffset");
3868                 p->loc_RefractColor               = qglGetUniformLocationARB(p->program, "RefractColor");
3869                 p->loc_Saturation                 = qglGetUniformLocationARB(p->program, "Saturation");
3870                 p->loc_ScreenCenterRefractReflect = qglGetUniformLocationARB(p->program, "ScreenCenterRefractReflect");
3871                 p->loc_ScreenScaleRefractReflect  = qglGetUniformLocationARB(p->program, "ScreenScaleRefractReflect");
3872                 p->loc_ScreenToDepth              = qglGetUniformLocationARB(p->program, "ScreenToDepth");
3873                 p->loc_ShadowMap_Parameters       = qglGetUniformLocationARB(p->program, "ShadowMap_Parameters");
3874                 p->loc_ShadowMap_TextureScale     = qglGetUniformLocationARB(p->program, "ShadowMap_TextureScale");
3875                 p->loc_SpecularPower              = qglGetUniformLocationARB(p->program, "SpecularPower");
3876                 p->loc_UserVec1                   = qglGetUniformLocationARB(p->program, "UserVec1");
3877                 p->loc_UserVec2                   = qglGetUniformLocationARB(p->program, "UserVec2");
3878                 p->loc_UserVec3                   = qglGetUniformLocationARB(p->program, "UserVec3");
3879                 p->loc_UserVec4                   = qglGetUniformLocationARB(p->program, "UserVec4");
3880                 p->loc_ViewTintColor              = qglGetUniformLocationARB(p->program, "ViewTintColor");
3881                 p->loc_ViewToLight                = qglGetUniformLocationARB(p->program, "ViewToLight");
3882                 p->loc_ModelToLight               = qglGetUniformLocationARB(p->program, "ModelToLight");
3883                 p->loc_TexMatrix                  = qglGetUniformLocationARB(p->program, "TexMatrix");
3884                 p->loc_BackgroundTexMatrix        = qglGetUniformLocationARB(p->program, "BackgroundTexMatrix");
3885                 p->loc_ModelViewMatrix            = qglGetUniformLocationARB(p->program, "ModelViewMatrix");
3886                 p->loc_ModelViewProjectionMatrix  = qglGetUniformLocationARB(p->program, "ModelViewProjectionMatrix");
3887                 p->loc_PixelToScreenTexCoord      = qglGetUniformLocationARB(p->program, "PixelToScreenTexCoord");
3888                 p->loc_ModelToReflectCube         = qglGetUniformLocationARB(p->program, "ModelToReflectCube");
3889                 p->loc_ShadowMapMatrix            = qglGetUniformLocationARB(p->program, "ShadowMapMatrix");
3890                 p->loc_BloomColorSubtract         = qglGetUniformLocationARB(p->program, "BloomColorSubtract");
3891                 p->loc_NormalmapScrollBlend       = qglGetUniformLocationARB(p->program, "NormalmapScrollBlend");
3892                 // initialize the samplers to refer to the texture units we use
3893                 if (p->loc_Texture_First           >= 0) qglUniform1iARB(p->loc_Texture_First          , GL20TU_FIRST);
3894                 if (p->loc_Texture_Second          >= 0) qglUniform1iARB(p->loc_Texture_Second         , GL20TU_SECOND);
3895                 if (p->loc_Texture_GammaRamps      >= 0) qglUniform1iARB(p->loc_Texture_GammaRamps     , GL20TU_GAMMARAMPS);
3896                 if (p->loc_Texture_Normal          >= 0) qglUniform1iARB(p->loc_Texture_Normal         , GL20TU_NORMAL);
3897                 if (p->loc_Texture_Color           >= 0) qglUniform1iARB(p->loc_Texture_Color          , GL20TU_COLOR);
3898                 if (p->loc_Texture_Gloss           >= 0) qglUniform1iARB(p->loc_Texture_Gloss          , GL20TU_GLOSS);
3899                 if (p->loc_Texture_Glow            >= 0) qglUniform1iARB(p->loc_Texture_Glow           , GL20TU_GLOW);
3900                 if (p->loc_Texture_SecondaryNormal >= 0) qglUniform1iARB(p->loc_Texture_SecondaryNormal, GL20TU_SECONDARY_NORMAL);
3901                 if (p->loc_Texture_SecondaryColor  >= 0) qglUniform1iARB(p->loc_Texture_SecondaryColor , GL20TU_SECONDARY_COLOR);
3902                 if (p->loc_Texture_SecondaryGloss  >= 0) qglUniform1iARB(p->loc_Texture_SecondaryGloss , GL20TU_SECONDARY_GLOSS);
3903                 if (p->loc_Texture_SecondaryGlow   >= 0) qglUniform1iARB(p->loc_Texture_SecondaryGlow  , GL20TU_SECONDARY_GLOW);
3904                 if (p->loc_Texture_Pants           >= 0) qglUniform1iARB(p->loc_Texture_Pants          , GL20TU_PANTS);
3905                 if (p->loc_Texture_Shirt           >= 0) qglUniform1iARB(p->loc_Texture_Shirt          , GL20TU_SHIRT);
3906                 if (p->loc_Texture_FogHeightTexture>= 0) qglUniform1iARB(p->loc_Texture_FogHeightTexture, GL20TU_FOGHEIGHTTEXTURE);
3907                 if (p->loc_Texture_FogMask         >= 0) qglUniform1iARB(p->loc_Texture_FogMask        , GL20TU_FOGMASK);
3908                 if (p->loc_Texture_Lightmap        >= 0) qglUniform1iARB(p->loc_Texture_Lightmap       , GL20TU_LIGHTMAP);
3909                 if (p->loc_Texture_Deluxemap       >= 0) qglUniform1iARB(p->loc_Texture_Deluxemap      , GL20TU_DELUXEMAP);
3910                 if (p->loc_Texture_Attenuation     >= 0) qglUniform1iARB(p->loc_Texture_Attenuation    , GL20TU_ATTENUATION);
3911                 if (p->loc_Texture_Cube            >= 0) qglUniform1iARB(p->loc_Texture_Cube           , GL20TU_CUBE);
3912                 if (p->loc_Texture_Refraction      >= 0) qglUniform1iARB(p->loc_Texture_Refraction     , GL20TU_REFRACTION);
3913                 if (p->loc_Texture_Reflection      >= 0) qglUniform1iARB(p->loc_Texture_Reflection     , GL20TU_REFLECTION);
3914                 if (p->loc_Texture_ShadowMap2D     >= 0) qglUniform1iARB(p->loc_Texture_ShadowMap2D    , GL20TU_SHADOWMAP2D);
3915                 if (p->loc_Texture_CubeProjection  >= 0) qglUniform1iARB(p->loc_Texture_CubeProjection , GL20TU_CUBEPROJECTION);
3916                 if (p->loc_Texture_ScreenDepth     >= 0) qglUniform1iARB(p->loc_Texture_ScreenDepth    , GL20TU_SCREENDEPTH);
3917                 if (p->loc_Texture_ScreenNormalMap >= 0) qglUniform1iARB(p->loc_Texture_ScreenNormalMap, GL20TU_SCREENNORMALMAP);
3918                 if (p->loc_Texture_ScreenDiffuse   >= 0) qglUniform1iARB(p->loc_Texture_ScreenDiffuse  , GL20TU_SCREENDIFFUSE);
3919                 if (p->loc_Texture_ScreenSpecular  >= 0) qglUniform1iARB(p->loc_Texture_ScreenSpecular , GL20TU_SCREENSPECULAR);
3920                 if (p->loc_Texture_ReflectMask     >= 0) qglUniform1iARB(p->loc_Texture_ReflectMask    , GL20TU_REFLECTMASK);
3921                 if (p->loc_Texture_ReflectCube     >= 0) qglUniform1iARB(p->loc_Texture_ReflectCube    , GL20TU_REFLECTCUBE);
3922                 CHECKGLERROR
3923                 Con_DPrintf("^5GLSL shader %s compiled.\n", permutationname);
3924         }
3925         else
3926                 Con_Printf("^1GLSL shader %s failed!  some features may not work properly.\n", permutationname);
3927
3928         // free the strings
3929         if (vertexstring)
3930                 Mem_Free(vertexstring);
3931         if (geometrystring)
3932                 Mem_Free(geometrystring);
3933         if (fragmentstring)
3934                 Mem_Free(fragmentstring);
3935 }
3936
3937 void R_SetupShader_SetPermutationGLSL(unsigned int mode, unsigned int permutation)
3938 {
3939         r_glsl_permutation_t *perm = R_GLSL_FindPermutation(mode, permutation);
3940         if (r_glsl_permutation != perm)
3941         {
3942                 r_glsl_permutation = perm;
3943                 if (!r_glsl_permutation->program)
3944                 {
3945                         if (!r_glsl_permutation->compiled)
3946                                 R_GLSL_CompilePermutation(perm, mode, permutation);
3947                         if (!r_glsl_permutation->program)
3948                         {
3949                                 // remove features until we find a valid permutation
3950                                 int i;
3951                                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
3952                                 {
3953                                         // reduce i more quickly whenever it would not remove any bits
3954                                         int j = 1<<(SHADERPERMUTATION_COUNT-1-i);
3955                                         if (!(permutation & j))
3956                                                 continue;
3957                                         permutation -= j;
3958                                         r_glsl_permutation = R_GLSL_FindPermutation(mode, permutation);
3959                                         if (!r_glsl_permutation->compiled)
3960                                                 R_GLSL_CompilePermutation(perm, mode, permutation);
3961                                         if (r_glsl_permutation->program)
3962                                                 break;
3963                                 }
3964                                 if (i >= SHADERPERMUTATION_COUNT)
3965                                 {
3966                                         //Con_Printf("Could not find a working OpenGL 2.0 shader for permutation %s %s\n", shadermodeinfo[mode].vertexfilename, shadermodeinfo[mode].pretext);
3967                                         r_glsl_permutation = R_GLSL_FindPermutation(mode, permutation);
3968                                         qglUseProgramObjectARB(0);CHECKGLERROR
3969                                         return; // no bit left to clear, entire mode is broken
3970                                 }
3971                         }
3972                 }
3973                 CHECKGLERROR
3974                 qglUseProgramObjectARB(r_glsl_permutation->program);CHECKGLERROR
3975         }
3976         if (r_glsl_permutation->loc_ModelViewProjectionMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewProjectionMatrix, 1, false, gl_modelviewprojection16f);
3977         if (r_glsl_permutation->loc_ModelViewMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewMatrix, 1, false, gl_modelview16f);
3978         if (r_glsl_permutation->loc_ClientTime >= 0) qglUniform1fARB(r_glsl_permutation->loc_ClientTime, cl.time);
3979 }
3980
3981 #ifdef SUPPORTCG
3982 #include <Cg/cgGL.h>
3983 struct r_cg_permutation_s;
3984 typedef struct r_cg_permutation_s
3985 {
3986         /// hash lookup data
3987         struct r_cg_permutation_s *hashnext;
3988         unsigned int mode;
3989         unsigned int permutation;
3990
3991         /// indicates if we have tried compiling this permutation already
3992         qboolean compiled;
3993         /// 0 if compilation failed
3994         CGprogram vprogram;
3995         CGprogram fprogram;
3996         /// locations of detected parameters in programs, or NULL if not found
3997         CGparameter vp_EyePosition;
3998         CGparameter vp_FogPlane;
3999         CGparameter vp_LightDir;
4000         CGparameter vp_LightPosition;
4001         CGparameter vp_ModelToLight;
4002         CGparameter vp_TexMatrix;
4003         CGparameter vp_BackgroundTexMatrix;
4004         CGparameter vp_ModelViewProjectionMatrix;
4005         CGparameter vp_ModelViewMatrix;
4006         CGparameter vp_ShadowMapMatrix;
4007
4008         CGparameter fp_Texture_First;
4009         CGparameter fp_Texture_Second;
4010         CGparameter fp_Texture_GammaRamps;
4011         CGparameter fp_Texture_Normal;
4012         CGparameter fp_Texture_Color;
4013         CGparameter fp_Texture_Gloss;
4014         CGparameter fp_Texture_Glow;
4015         CGparameter fp_Texture_SecondaryNormal;
4016         CGparameter fp_Texture_SecondaryColor;
4017         CGparameter fp_Texture_SecondaryGloss;
4018         CGparameter fp_Texture_SecondaryGlow;
4019         CGparameter fp_Texture_Pants;
4020         CGparameter fp_Texture_Shirt;
4021         CGparameter fp_Texture_FogHeightTexture;
4022         CGparameter fp_Texture_FogMask;
4023         CGparameter fp_Texture_Lightmap;
4024         CGparameter fp_Texture_Deluxemap;
4025         CGparameter fp_Texture_Attenuation;
4026         CGparameter fp_Texture_Cube;
4027         CGparameter fp_Texture_Refraction;
4028         CGparameter fp_Texture_Reflection;
4029         CGparameter fp_Texture_ShadowMap2D;
4030         CGparameter fp_Texture_CubeProjection;
4031         CGparameter fp_Texture_ScreenDepth;
4032         CGparameter fp_Texture_ScreenNormalMap;
4033         CGparameter fp_Texture_ScreenDiffuse;
4034         CGparameter fp_Texture_ScreenSpecular;
4035         CGparameter fp_Texture_ReflectMask;
4036         CGparameter fp_Texture_ReflectCube;
4037         CGparameter fp_Alpha;
4038         CGparameter fp_BloomBlur_Parameters;
4039         CGparameter fp_ClientTime;
4040         CGparameter fp_Color_Ambient;
4041         CGparameter fp_Color_Diffuse;
4042         CGparameter fp_Color_Specular;
4043         CGparameter fp_Color_Glow;
4044         CGparameter fp_Color_Pants;
4045         CGparameter fp_Color_Shirt;
4046         CGparameter fp_DeferredColor_Ambient;
4047         CGparameter fp_DeferredColor_Diffuse;
4048         CGparameter fp_DeferredColor_Specular;
4049         CGparameter fp_DeferredMod_Diffuse;
4050         CGparameter fp_DeferredMod_Specular;
4051         CGparameter fp_DistortScaleRefractReflect;
4052         CGparameter fp_EyePosition;
4053         CGparameter fp_FogColor;
4054         CGparameter fp_FogHeightFade;
4055         CGparameter fp_FogPlane;
4056         CGparameter fp_FogPlaneViewDist;
4057         CGparameter fp_FogRangeRecip;
4058         CGparameter fp_LightColor;
4059         CGparameter fp_LightDir;
4060         CGparameter fp_LightPosition;
4061         CGparameter fp_OffsetMapping_Scale;
4062         CGparameter fp_PixelSize;
4063         CGparameter fp_ReflectColor;
4064         CGparameter fp_ReflectFactor;
4065         CGparameter fp_ReflectOffset;
4066         CGparameter fp_RefractColor;
4067         CGparameter fp_Saturation;
4068         CGparameter fp_ScreenCenterRefractReflect;
4069         CGparameter fp_ScreenScaleRefractReflect;
4070         CGparameter fp_ScreenToDepth;
4071         CGparameter fp_ShadowMap_Parameters;
4072         CGparameter fp_ShadowMap_TextureScale;
4073         CGparameter fp_SpecularPower;
4074         CGparameter fp_UserVec1;
4075         CGparameter fp_UserVec2;
4076         CGparameter fp_UserVec3;
4077         CGparameter fp_UserVec4;
4078         CGparameter fp_ViewTintColor;
4079         CGparameter fp_ViewToLight;
4080         CGparameter fp_PixelToScreenTexCoord;
4081         CGparameter fp_ModelToReflectCube;
4082         CGparameter fp_BloomColorSubtract;
4083         CGparameter fp_NormalmapScrollBlend;
4084 }
4085 r_cg_permutation_t;
4086
4087 /// information about each possible shader permutation
4088 r_cg_permutation_t *r_cg_permutationhash[SHADERMODE_COUNT][SHADERPERMUTATION_HASHSIZE];
4089 /// currently selected permutation
4090 r_cg_permutation_t *r_cg_permutation;
4091 /// storage for permutations linked in the hash table
4092 memexpandablearray_t r_cg_permutationarray;
4093
4094 #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));}}
4095
4096 static r_cg_permutation_t *R_CG_FindPermutation(unsigned int mode, unsigned int permutation)
4097 {
4098         //unsigned int hashdepth = 0;
4099         unsigned int hashindex = (permutation * 0x1021) & (SHADERPERMUTATION_HASHSIZE - 1);
4100         r_cg_permutation_t *p;
4101         for (p = r_cg_permutationhash[mode][hashindex];p;p = p->hashnext)
4102         {
4103                 if (p->mode == mode && p->permutation == permutation)
4104                 {
4105                         //if (hashdepth > 10)
4106                         //      Con_Printf("R_CG_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
4107                         return p;
4108                 }
4109                 //hashdepth++;
4110         }
4111         p = (r_cg_permutation_t*)Mem_ExpandableArray_AllocRecord(&r_cg_permutationarray);
4112         p->mode = mode;
4113         p->permutation = permutation;
4114         p->hashnext = r_cg_permutationhash[mode][hashindex];
4115         r_cg_permutationhash[mode][hashindex] = p;
4116         //if (hashdepth > 10)
4117         //      Con_Printf("R_CG_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
4118         return p;
4119 }
4120
4121 static char *R_CG_GetText(const char *filename, qboolean printfromdisknotice)
4122 {
4123         char *shaderstring;
4124         if (!filename || !filename[0])
4125                 return NULL;
4126         if (!strcmp(filename, "cg/default.cg"))
4127         {
4128                 if (!cgshaderstring)
4129                 {
4130                         cgshaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
4131                         if (cgshaderstring)
4132                                 Con_DPrintf("Loading shaders from file %s...\n", filename);
4133                         else
4134                                 cgshaderstring = (char *)builtincgshaderstring;
4135                 }
4136                 shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(cgshaderstring) + 1);
4137                 memcpy(shaderstring, cgshaderstring, strlen(cgshaderstring) + 1);
4138                 return shaderstring;
4139         }
4140         shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
4141         if (shaderstring)
4142         {
4143                 if (printfromdisknotice)
4144                         Con_DPrintf("from disk %s... ", filename);
4145                 return shaderstring;
4146         }
4147         return shaderstring;
4148 }
4149
4150 static void R_CG_CacheShader(r_cg_permutation_t *p, const char *cachename, const char *vertstring, const char *fragstring)
4151 {
4152         // TODO: load or create .fp and .vp shader files
4153 }
4154
4155 static void R_CG_CompilePermutation(r_cg_permutation_t *p, unsigned int mode, unsigned int permutation)
4156 {
4157         int i;
4158         shadermodeinfo_t *modeinfo = cgshadermodeinfo + mode;
4159         int vertstring_length = 0;
4160         int geomstring_length = 0;
4161         int fragstring_length = 0;
4162         char *t;
4163         char *vertexstring, *geometrystring, *fragmentstring;
4164         char *vertstring, *geomstring, *fragstring;
4165         char permutationname[256];
4166         char cachename[256];
4167         CGprofile vertexProfile;
4168         CGprofile fragmentProfile;
4169         int vertstrings_count = 0;
4170         int geomstrings_count = 0;
4171         int fragstrings_count = 0;
4172         const char *vertstrings_list[32+3+SHADERSTATICPARMS_COUNT+1];
4173         const char *geomstrings_list[32+3+SHADERSTATICPARMS_COUNT+1];
4174         const char *fragstrings_list[32+3+SHADERSTATICPARMS_COUNT+1];
4175
4176         if (p->compiled)
4177                 return;
4178         p->compiled = true;
4179         p->vprogram = NULL;
4180         p->fprogram = NULL;
4181
4182         permutationname[0] = 0;
4183         cachename[0] = 0;
4184         vertexstring   = R_CG_GetText(modeinfo->vertexfilename, true);
4185         geometrystring = R_CG_GetText(modeinfo->geometryfilename, false);
4186         fragmentstring = R_CG_GetText(modeinfo->fragmentfilename, false);
4187
4188         strlcat(permutationname, modeinfo->vertexfilename, sizeof(permutationname));
4189         strlcat(cachename, "cg/", sizeof(cachename));
4190
4191         // the first pretext is which type of shader to compile as
4192         // (later these will all be bound together as a program object)
4193         vertstrings_list[vertstrings_count++] = "#define VERTEX_SHADER\n";
4194         geomstrings_list[geomstrings_count++] = "#define GEOMETRY_SHADER\n";
4195         fragstrings_list[fragstrings_count++] = "#define FRAGMENT_SHADER\n";
4196
4197         // the second pretext is the mode (for example a light source)
4198         vertstrings_list[vertstrings_count++] = modeinfo->pretext;
4199         geomstrings_list[geomstrings_count++] = modeinfo->pretext;
4200         fragstrings_list[fragstrings_count++] = modeinfo->pretext;
4201         strlcat(permutationname, modeinfo->name, sizeof(permutationname));
4202         strlcat(cachename, modeinfo->name, sizeof(cachename));
4203
4204         // now add all the permutation pretexts
4205         for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
4206         {
4207                 if (permutation & (1<<i))
4208                 {
4209                         vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i].pretext;
4210                         geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i].pretext;
4211                         fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i].pretext;
4212                         strlcat(permutationname, shaderpermutationinfo[i].name, sizeof(permutationname));
4213                         strlcat(cachename, shaderpermutationinfo[i].name, sizeof(cachename));
4214                 }
4215                 else
4216                 {
4217                         // keep line numbers correct
4218                         vertstrings_list[vertstrings_count++] = "\n";
4219                         geomstrings_list[geomstrings_count++] = "\n";
4220                         fragstrings_list[fragstrings_count++] = "\n";
4221                 }
4222         }
4223
4224         // add static parms
4225         R_CompileShader_AddStaticParms(mode, permutation);
4226         memcpy(vertstrings_list + vertstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
4227         vertstrings_count += shaderstaticparms_count;
4228         memcpy(geomstrings_list + geomstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
4229         geomstrings_count += shaderstaticparms_count;
4230         memcpy(fragstrings_list + fragstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
4231         fragstrings_count += shaderstaticparms_count;
4232
4233         // replace spaces in the cachename with _ characters
4234         for (i = 0;cachename[i];i++)
4235                 if (cachename[i] == ' ')
4236                         cachename[i] = '_';
4237
4238         // now append the shader text itself
4239         vertstrings_list[vertstrings_count++] = vertexstring;
4240         geomstrings_list[geomstrings_count++] = geometrystring;
4241         fragstrings_list[fragstrings_count++] = fragmentstring;
4242
4243         // if any sources were NULL, clear the respective list
4244         if (!vertexstring)
4245                 vertstrings_count = 0;
4246         if (!geometrystring)
4247                 geomstrings_count = 0;
4248         if (!fragmentstring)
4249                 fragstrings_count = 0;
4250
4251         vertstring_length = 0;
4252         for (i = 0;i < vertstrings_count;i++)
4253                 vertstring_length += strlen(vertstrings_list[i]);
4254         vertstring = t = Mem_Alloc(tempmempool, vertstring_length + 1);
4255         for (i = 0;i < vertstrings_count;t += strlen(vertstrings_list[i]), i++)
4256                 memcpy(t, vertstrings_list[i], strlen(vertstrings_list[i]));
4257
4258         geomstring_length = 0;
4259         for (i = 0;i < geomstrings_count;i++)
4260                 geomstring_length += strlen(geomstrings_list[i]);
4261         geomstring = t = Mem_Alloc(tempmempool, geomstring_length + 1);
4262         for (i = 0;i < geomstrings_count;t += strlen(geomstrings_list[i]), i++)
4263                 memcpy(t, geomstrings_list[i], strlen(geomstrings_list[i]));
4264
4265         fragstring_length = 0;
4266         for (i = 0;i < fragstrings_count;i++)
4267                 fragstring_length += strlen(fragstrings_list[i]);
4268         fragstring = t = Mem_Alloc(tempmempool, fragstring_length + 1);
4269         for (i = 0;i < fragstrings_count;t += strlen(fragstrings_list[i]), i++)
4270                 memcpy(t, fragstrings_list[i], strlen(fragstrings_list[i]));
4271
4272         CHECKGLERROR
4273         CHECKCGERROR
4274         //vertexProfile = CG_PROFILE_ARBVP1;
4275         //fragmentProfile = CG_PROFILE_ARBFP1;
4276         vertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX);CHECKCGERROR
4277         fragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);CHECKCGERROR
4278         //cgGLSetOptimalOptions(vertexProfile);CHECKCGERROR
4279         //cgGLSetOptimalOptions(fragmentProfile);CHECKCGERROR
4280         //cgSetAutoCompile(vid.cgcontext, CG_COMPILE_MANUAL);CHECKCGERROR
4281         CHECKGLERROR
4282
4283         // try to load the cached shader, or generate one
4284         R_CG_CacheShader(p, cachename, vertstring, fragstring);
4285
4286         // if caching failed, do a dynamic compile for now
4287         CHECKCGERROR
4288         if (vertstring[0] && !p->vprogram)
4289                 p->vprogram = cgCreateProgram(vid.cgcontext, CG_SOURCE, vertstring, vertexProfile, NULL, NULL);
4290         CHECKCGERROR
4291         if (fragstring[0] && !p->fprogram)
4292                 p->fprogram = cgCreateProgram(vid.cgcontext, CG_SOURCE, fragstring, fragmentProfile, NULL, NULL);
4293         CHECKCGERROR
4294
4295         // look up all the uniform variable names we care about, so we don't
4296         // have to look them up every time we set them
4297         if (p->vprogram)
4298         {
4299                 CHECKCGERROR
4300                 cgGLLoadProgram(p->vprogram);CHECKCGERROR CHECKGLERROR
4301                 cgGLEnableProfile(vertexProfile);CHECKCGERROR CHECKGLERROR
4302                 p->vp_EyePosition                = cgGetNamedParameter(p->vprogram, "EyePosition");
4303                 p->vp_FogPlane                   = cgGetNamedParameter(p->vprogram, "FogPlane");
4304                 p->vp_LightDir                   = cgGetNamedParameter(p->vprogram, "LightDir");
4305                 p->vp_LightPosition              = cgGetNamedParameter(p->vprogram, "LightPosition");
4306                 p->vp_ModelToLight               = cgGetNamedParameter(p->vprogram, "ModelToLight");
4307                 p->vp_TexMatrix                  = cgGetNamedParameter(p->vprogram, "TexMatrix");
4308                 p->vp_BackgroundTexMatrix        = cgGetNamedParameter(p->vprogram, "BackgroundTexMatrix");
4309                 p->vp_ModelViewProjectionMatrix  = cgGetNamedParameter(p->vprogram, "ModelViewProjectionMatrix");
4310                 p->vp_ModelViewMatrix            = cgGetNamedParameter(p->vprogram, "ModelViewMatrix");
4311                 p->vp_ShadowMapMatrix            = cgGetNamedParameter(p->vprogram, "ShadowMapMatrix");
4312                 CHECKCGERROR
4313         }
4314         if (p->fprogram)
4315         {
4316                 CHECKCGERROR
4317                 cgGLLoadProgram(p->fprogram);CHECKCGERROR CHECKGLERROR
4318                 cgGLEnableProfile(fragmentProfile);CHECKCGERROR CHECKGLERROR
4319                 p->fp_Texture_First              = cgGetNamedParameter(p->fprogram, "Texture_First");
4320                 p->fp_Texture_Second             = cgGetNamedParameter(p->fprogram, "Texture_Second");
4321                 p->fp_Texture_GammaRamps         = cgGetNamedParameter(p->fprogram, "Texture_GammaRamps");
4322                 p->fp_Texture_Normal             = cgGetNamedParameter(p->fprogram, "Texture_Normal");
4323                 p->fp_Texture_Color              = cgGetNamedParameter(p->fprogram, "Texture_Color");
4324                 p->fp_Texture_Gloss              = cgGetNamedParameter(p->fprogram, "Texture_Gloss");
4325                 p->fp_Texture_Glow               = cgGetNamedParameter(p->fprogram, "Texture_Glow");
4326                 p->fp_Texture_SecondaryNormal    = cgGetNamedParameter(p->fprogram, "Texture_SecondaryNormal");
4327                 p->fp_Texture_SecondaryColor     = cgGetNamedParameter(p->fprogram, "Texture_SecondaryColor");
4328                 p->fp_Texture_SecondaryGloss     = cgGetNamedParameter(p->fprogram, "Texture_SecondaryGloss");
4329                 p->fp_Texture_SecondaryGlow      = cgGetNamedParameter(p->fprogram, "Texture_SecondaryGlow");
4330                 p->fp_Texture_Pants              = cgGetNamedParameter(p->fprogram, "Texture_Pants");
4331                 p->fp_Texture_Shirt              = cgGetNamedParameter(p->fprogram, "Texture_Shirt");
4332                 p->fp_Texture_FogHeightTexture   = cgGetNamedParameter(p->fprogram, "Texture_FogHeightTexture");
4333                 p->fp_Texture_FogMask            = cgGetNamedParameter(p->fprogram, "Texture_FogMask");
4334                 p->fp_Texture_Lightmap           = cgGetNamedParameter(p->fprogram, "Texture_Lightmap");
4335                 p->fp_Texture_Deluxemap          = cgGetNamedParameter(p->fprogram, "Texture_Deluxemap");
4336                 p->fp_Texture_Attenuation        = cgGetNamedParameter(p->fprogram, "Texture_Attenuation");
4337                 p->fp_Texture_Cube               = cgGetNamedParameter(p->fprogram, "Texture_Cube");
4338                 p->fp_Texture_Refraction         = cgGetNamedParameter(p->fprogram, "Texture_Refraction");
4339                 p->fp_Texture_Reflection         = cgGetNamedParameter(p->fprogram, "Texture_Reflection");
4340                 p->fp_Texture_ShadowMap2D        = cgGetNamedParameter(p->fprogram, "Texture_ShadowMap2D");
4341                 p->fp_Texture_CubeProjection     = cgGetNamedParameter(p->fprogram, "Texture_CubeProjection");
4342                 p->fp_Texture_ScreenDepth        = cgGetNamedParameter(p->fprogram, "Texture_ScreenDepth");
4343                 p->fp_Texture_ScreenNormalMap    = cgGetNamedParameter(p->fprogram, "Texture_ScreenNormalMap");
4344                 p->fp_Texture_ScreenDiffuse      = cgGetNamedParameter(p->fprogram, "Texture_ScreenDiffuse");
4345                 p->fp_Texture_ScreenSpecular     = cgGetNamedParameter(p->fprogram, "Texture_ScreenSpecular");
4346                 p->fp_Texture_ReflectMask        = cgGetNamedParameter(p->fprogram, "Texture_ReflectMask");
4347                 p->fp_Texture_ReflectCube        = cgGetNamedParameter(p->fprogram, "Texture_ReflectCube");
4348                 p->fp_Alpha                      = cgGetNamedParameter(p->fprogram, "Alpha");
4349                 p->fp_BloomBlur_Parameters       = cgGetNamedParameter(p->fprogram, "BloomBlur_Parameters");
4350                 p->fp_ClientTime                 = cgGetNamedParameter(p->fprogram, "ClientTime");
4351                 p->fp_Color_Ambient              = cgGetNamedParameter(p->fprogram, "Color_Ambient");
4352                 p->fp_Color_Diffuse              = cgGetNamedParameter(p->fprogram, "Color_Diffuse");
4353                 p->fp_Color_Specular             = cgGetNamedParameter(p->fprogram, "Color_Specular");
4354                 p->fp_Color_Glow                 = cgGetNamedParameter(p->fprogram, "Color_Glow");
4355                 p->fp_Color_Pants                = cgGetNamedParameter(p->fprogram, "Color_Pants");
4356                 p->fp_Color_Shirt                = cgGetNamedParameter(p->fprogram, "Color_Shirt");
4357                 p->fp_DeferredColor_Ambient      = cgGetNamedParameter(p->fprogram, "DeferredColor_Ambient");
4358                 p->fp_DeferredColor_Diffuse      = cgGetNamedParameter(p->fprogram, "DeferredColor_Diffuse");
4359                 p->fp_DeferredColor_Specular     = cgGetNamedParameter(p->fprogram, "DeferredColor_Specular");
4360                 p->fp_DeferredMod_Diffuse        = cgGetNamedParameter(p->fprogram, "DeferredMod_Diffuse");
4361                 p->fp_DeferredMod_Specular       = cgGetNamedParameter(p->fprogram, "DeferredMod_Specular");
4362                 p->fp_DistortScaleRefractReflect = cgGetNamedParameter(p->fprogram, "DistortScaleRefractReflect");
4363                 p->fp_EyePosition                = cgGetNamedParameter(p->fprogram, "EyePosition");
4364                 p->fp_FogColor                   = cgGetNamedParameter(p->fprogram, "FogColor");
4365                 p->fp_FogHeightFade              = cgGetNamedParameter(p->fprogram, "FogHeightFade");
4366                 p->fp_FogPlane                   = cgGetNamedParameter(p->fprogram, "FogPlane");
4367                 p->fp_FogPlaneViewDist           = cgGetNamedParameter(p->fprogram, "FogPlaneViewDist");
4368                 p->fp_FogRangeRecip              = cgGetNamedParameter(p->fprogram, "FogRangeRecip");
4369                 p->fp_LightColor                 = cgGetNamedParameter(p->fprogram, "LightColor");
4370                 p->fp_LightDir                   = cgGetNamedParameter(p->fprogram, "LightDir");
4371                 p->fp_LightPosition              = cgGetNamedParameter(p->fprogram, "LightPosition");
4372                 p->fp_OffsetMapping_Scale        = cgGetNamedParameter(p->fprogram, "OffsetMapping_Scale");
4373                 p->fp_PixelSize                  = cgGetNamedParameter(p->fprogram, "PixelSize");
4374                 p->fp_ReflectColor               = cgGetNamedParameter(p->fprogram, "ReflectColor");
4375                 p->fp_ReflectFactor              = cgGetNamedParameter(p->fprogram, "ReflectFactor");
4376                 p->fp_ReflectOffset              = cgGetNamedParameter(p->fprogram, "ReflectOffset");
4377                 p->fp_RefractColor               = cgGetNamedParameter(p->fprogram, "RefractColor");
4378                 p->fp_Saturation                 = cgGetNamedParameter(p->fprogram, "Saturation");
4379                 p->fp_ScreenCenterRefractReflect = cgGetNamedParameter(p->fprogram, "ScreenCenterRefractReflect");
4380                 p->fp_ScreenScaleRefractReflect  = cgGetNamedParameter(p->fprogram, "ScreenScaleRefractReflect");
4381                 p->fp_ScreenToDepth              = cgGetNamedParameter(p->fprogram, "ScreenToDepth");
4382                 p->fp_ShadowMap_Parameters       = cgGetNamedParameter(p->fprogram, "ShadowMap_Parameters");
4383                 p->fp_ShadowMap_TextureScale     = cgGetNamedParameter(p->fprogram, "ShadowMap_TextureScale");
4384                 p->fp_SpecularPower              = cgGetNamedParameter(p->fprogram, "SpecularPower");
4385                 p->fp_UserVec1                   = cgGetNamedParameter(p->fprogram, "UserVec1");
4386                 p->fp_UserVec2                   = cgGetNamedParameter(p->fprogram, "UserVec2");
4387                 p->fp_UserVec3                   = cgGetNamedParameter(p->fprogram, "UserVec3");
4388                 p->fp_UserVec4                   = cgGetNamedParameter(p->fprogram, "UserVec4");
4389                 p->fp_ViewTintColor              = cgGetNamedParameter(p->fprogram, "ViewTintColor");
4390                 p->fp_ViewToLight                = cgGetNamedParameter(p->fprogram, "ViewToLight");
4391                 p->fp_PixelToScreenTexCoord      = cgGetNamedParameter(p->fprogram, "PixelToScreenTexCoord");
4392                 p->fp_ModelToReflectCube         = cgGetNamedParameter(p->fprogram, "ModelToReflectCube");
4393                 p->fp_BloomColorSubtract         = cgGetNamedParameter(p->fprogram, "BloomColorSubtract");
4394                 p->fp_NormalmapScrollBlend       = cgGetNamedParameter(p->fprogram, "NormalmapScrollBlend");
4395                 CHECKCGERROR
4396         }
4397
4398         if ((p->vprogram || !vertstring[0]) && (p->fprogram || !fragstring[0]))
4399                 Con_DPrintf("^5CG shader %s compiled.\n", permutationname);
4400         else
4401                 Con_Printf("^1CG shader %s failed!  some features may not work properly.\n", permutationname);
4402
4403         // free the strings
4404         if (vertstring)
4405                 Mem_Free(vertstring);
4406         if (geomstring)
4407                 Mem_Free(geomstring);
4408         if (fragstring)
4409                 Mem_Free(fragstring);
4410         if (vertexstring)
4411                 Mem_Free(vertexstring);
4412         if (geometrystring)
4413                 Mem_Free(geometrystring);
4414         if (fragmentstring)
4415                 Mem_Free(fragmentstring);
4416 }
4417
4418 void R_SetupShader_SetPermutationCG(unsigned int mode, unsigned int permutation)
4419 {
4420         r_cg_permutation_t *perm = R_CG_FindPermutation(mode, permutation);
4421         CHECKGLERROR
4422         CHECKCGERROR
4423         if (r_cg_permutation != perm)
4424         {
4425                 r_cg_permutation = perm;
4426                 if (!r_cg_permutation->vprogram && !r_cg_permutation->fprogram)
4427                 {
4428                         if (!r_cg_permutation->compiled)
4429                                 R_CG_CompilePermutation(perm, mode, permutation);
4430                         if (!r_cg_permutation->vprogram && !r_cg_permutation->fprogram)
4431                         {
4432                                 // remove features until we find a valid permutation
4433                                 int i;
4434                                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
4435                                 {
4436                                         // reduce i more quickly whenever it would not remove any bits
4437                                         int j = 1<<(SHADERPERMUTATION_COUNT-1-i);
4438                                         if (!(permutation & j))
4439                                                 continue;
4440                                         permutation -= j;
4441                                         r_cg_permutation = R_CG_FindPermutation(mode, permutation);
4442                                         if (!r_cg_permutation->compiled)
4443                                                 R_CG_CompilePermutation(perm, mode, permutation);
4444                                         if (r_cg_permutation->vprogram || r_cg_permutation->fprogram)
4445                                                 break;
4446                                 }
4447                                 if (i >= SHADERPERMUTATION_COUNT)
4448                                 {
4449                                         //Con_Printf("Could not find a working Cg shader for permutation %s %s\n", shadermodeinfo[mode].vertexfilename, shadermodeinfo[mode].pretext);
4450                                         r_cg_permutation = R_CG_FindPermutation(mode, permutation);
4451                                         return; // no bit left to clear, entire mode is broken
4452                                 }
4453                         }
4454                 }
4455                 CHECKGLERROR
4456                 CHECKCGERROR
4457                 if (r_cg_permutation->vprogram)
4458                 {
4459                         cgGLLoadProgram(r_cg_permutation->vprogram);CHECKCGERROR CHECKGLERROR
4460                         cgGLBindProgram(r_cg_permutation->vprogram);CHECKCGERROR CHECKGLERROR
4461                         cgGLEnableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
4462                 }
4463                 else
4464                 {
4465                         cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
4466                         cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
4467                 }
4468                 if (r_cg_permutation->fprogram)
4469                 {
4470                         cgGLLoadProgram(r_cg_permutation->fprogram);CHECKCGERROR CHECKGLERROR
4471                         cgGLBindProgram(r_cg_permutation->fprogram);CHECKCGERROR CHECKGLERROR
4472                         cgGLEnableProfile(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
4473                 }
4474                 else
4475                 {
4476                         cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
4477                         cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
4478                 }
4479         }
4480         CHECKCGERROR
4481         if (r_cg_permutation->vp_ModelViewProjectionMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewProjectionMatrix, gl_modelviewprojection16f);CHECKCGERROR
4482         if (r_cg_permutation->vp_ModelViewMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewMatrix, gl_modelview16f);CHECKCGERROR
4483         if (r_cg_permutation->fp_ClientTime) cgGLSetParameter1f(r_cg_permutation->fp_ClientTime, cl.time);CHECKCGERROR
4484 }
4485
4486 void CG_BindTexture(CGparameter param, rtexture_t *tex)
4487 {
4488         cgGLSetTextureParameter(param, R_GetTexture(tex));
4489         cgGLEnableTextureParameter(param);
4490 }
4491 #endif
4492
4493 #ifdef SUPPORTD3D
4494
4495 #ifdef SUPPORTD3D
4496 #include <d3d9.h>
4497 extern LPDIRECT3DDEVICE9 vid_d3d9dev;
4498 extern D3DCAPS9 vid_d3d9caps;
4499 #endif
4500
4501 struct r_hlsl_permutation_s;
4502 typedef struct r_hlsl_permutation_s
4503 {
4504         /// hash lookup data
4505         struct r_hlsl_permutation_s *hashnext;
4506         unsigned int mode;
4507         unsigned int permutation;
4508
4509         /// indicates if we have tried compiling this permutation already
4510         qboolean compiled;
4511         /// NULL if compilation failed
4512         IDirect3DVertexShader9 *vertexshader;
4513         IDirect3DPixelShader9 *pixelshader;
4514 }
4515 r_hlsl_permutation_t;
4516
4517 typedef enum D3DVSREGISTER_e
4518 {
4519         D3DVSREGISTER_TexMatrix = 0, // float4x4
4520         D3DVSREGISTER_BackgroundTexMatrix = 4, // float4x4
4521         D3DVSREGISTER_ModelViewProjectionMatrix = 8, // float4x4
4522         D3DVSREGISTER_ModelViewMatrix = 12, // float4x4
4523         D3DVSREGISTER_ShadowMapMatrix = 16, // float4x4
4524         D3DVSREGISTER_ModelToLight = 20, // float4x4
4525         D3DVSREGISTER_EyePosition = 24,
4526         D3DVSREGISTER_FogPlane = 25,
4527         D3DVSREGISTER_LightDir = 26,
4528         D3DVSREGISTER_LightPosition = 27,
4529 }
4530 D3DVSREGISTER_t;
4531
4532 typedef enum D3DPSREGISTER_e
4533 {
4534         D3DPSREGISTER_Alpha = 0,
4535         D3DPSREGISTER_BloomBlur_Parameters = 1,
4536         D3DPSREGISTER_ClientTime = 2,
4537         D3DPSREGISTER_Color_Ambient = 3,
4538         D3DPSREGISTER_Color_Diffuse = 4,
4539         D3DPSREGISTER_Color_Specular = 5,
4540         D3DPSREGISTER_Color_Glow = 6,
4541         D3DPSREGISTER_Color_Pants = 7,
4542         D3DPSREGISTER_Color_Shirt = 8,
4543         D3DPSREGISTER_DeferredColor_Ambient = 9,
4544         D3DPSREGISTER_DeferredColor_Diffuse = 10,
4545         D3DPSREGISTER_DeferredColor_Specular = 11,
4546         D3DPSREGISTER_DeferredMod_Diffuse = 12,
4547         D3DPSREGISTER_DeferredMod_Specular = 13,
4548         D3DPSREGISTER_DistortScaleRefractReflect = 14,
4549         D3DPSREGISTER_EyePosition = 15, // unused
4550         D3DPSREGISTER_FogColor = 16,
4551         D3DPSREGISTER_FogHeightFade = 17,
4552         D3DPSREGISTER_FogPlane = 18,
4553         D3DPSREGISTER_FogPlaneViewDist = 19,
4554         D3DPSREGISTER_FogRangeRecip = 20,
4555         D3DPSREGISTER_LightColor = 21,
4556         D3DPSREGISTER_LightDir = 22, // unused
4557         D3DPSREGISTER_LightPosition = 23,
4558         D3DPSREGISTER_OffsetMapping_Scale = 24,
4559         D3DPSREGISTER_PixelSize = 25,
4560         D3DPSREGISTER_ReflectColor = 26,
4561         D3DPSREGISTER_ReflectFactor = 27,
4562         D3DPSREGISTER_ReflectOffset = 28,
4563         D3DPSREGISTER_RefractColor = 29,
4564         D3DPSREGISTER_Saturation = 30,
4565         D3DPSREGISTER_ScreenCenterRefractReflect = 31,
4566         D3DPSREGISTER_ScreenScaleRefractReflect = 32,
4567         D3DPSREGISTER_ScreenToDepth = 33,
4568         D3DPSREGISTER_ShadowMap_Parameters = 34,
4569         D3DPSREGISTER_ShadowMap_TextureScale = 35,
4570         D3DPSREGISTER_SpecularPower = 36,
4571         D3DPSREGISTER_UserVec1 = 37,
4572         D3DPSREGISTER_UserVec2 = 38,
4573         D3DPSREGISTER_UserVec3 = 39,
4574         D3DPSREGISTER_UserVec4 = 40,
4575         D3DPSREGISTER_ViewTintColor = 41,
4576         D3DPSREGISTER_PixelToScreenTexCoord = 42,
4577         D3DPSREGISTER_BloomColorSubtract = 43,
4578         D3DPSREGISTER_ViewToLight = 44, // float4x4
4579         D3DPSREGISTER_ModelToReflectCube = 48, // float4x4
4580         D3DPSREGISTER_NormalmapScrollBlend = 52,
4581         // next at 53
4582 }
4583 D3DPSREGISTER_t;
4584
4585 /// information about each possible shader permutation
4586 r_hlsl_permutation_t *r_hlsl_permutationhash[SHADERMODE_COUNT][SHADERPERMUTATION_HASHSIZE];
4587 /// currently selected permutation
4588 r_hlsl_permutation_t *r_hlsl_permutation;
4589 /// storage for permutations linked in the hash table
4590 memexpandablearray_t r_hlsl_permutationarray;
4591
4592 static r_hlsl_permutation_t *R_HLSL_FindPermutation(unsigned int mode, unsigned int permutation)
4593 {
4594         //unsigned int hashdepth = 0;
4595         unsigned int hashindex = (permutation * 0x1021) & (SHADERPERMUTATION_HASHSIZE - 1);
4596         r_hlsl_permutation_t *p;
4597         for (p = r_hlsl_permutationhash[mode][hashindex];p;p = p->hashnext)
4598         {
4599                 if (p->mode == mode && p->permutation == permutation)
4600                 {
4601                         //if (hashdepth > 10)
4602                         //      Con_Printf("R_HLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
4603                         return p;
4604                 }
4605                 //hashdepth++;
4606         }
4607         p = (r_hlsl_permutation_t*)Mem_ExpandableArray_AllocRecord(&r_hlsl_permutationarray);
4608         p->mode = mode;
4609         p->permutation = permutation;
4610         p->hashnext = r_hlsl_permutationhash[mode][hashindex];
4611         r_hlsl_permutationhash[mode][hashindex] = p;
4612         //if (hashdepth > 10)
4613         //      Con_Printf("R_HLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
4614         return p;
4615 }
4616
4617 static char *R_HLSL_GetText(const char *filename, qboolean printfromdisknotice)
4618 {
4619         char *shaderstring;
4620         if (!filename || !filename[0])
4621                 return NULL;
4622         if (!strcmp(filename, "hlsl/default.hlsl"))
4623         {
4624                 if (!hlslshaderstring)
4625                 {
4626                         hlslshaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
4627                         if (hlslshaderstring)
4628                                 Con_DPrintf("Loading shaders from file %s...\n", filename);
4629                         else
4630                                 hlslshaderstring = (char *)builtincgshaderstring;
4631                 }
4632                 shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(hlslshaderstring) + 1);
4633                 memcpy(shaderstring, hlslshaderstring, strlen(hlslshaderstring) + 1);
4634                 return shaderstring;
4635         }
4636         shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
4637         if (shaderstring)
4638         {
4639                 if (printfromdisknotice)
4640                         Con_DPrintf("from disk %s... ", filename);
4641                 return shaderstring;
4642         }
4643         return shaderstring;
4644 }
4645
4646 #include <d3dx9.h>
4647 //#include <d3dx9shader.h>
4648 //#include <d3dx9mesh.h>
4649
4650 static void R_HLSL_CacheShader(r_hlsl_permutation_t *p, const char *cachename, const char *vertstring, const char *fragstring)
4651 {
4652         DWORD *vsbin = NULL;
4653         DWORD *psbin = NULL;
4654         fs_offset_t vsbinsize;
4655         fs_offset_t psbinsize;
4656 //      IDirect3DVertexShader9 *vs = NULL;
4657 //      IDirect3DPixelShader9 *ps = NULL;
4658         ID3DXBuffer *vslog = NULL;
4659         ID3DXBuffer *vsbuffer = NULL;
4660         ID3DXConstantTable *vsconstanttable = NULL;
4661         ID3DXBuffer *pslog = NULL;
4662         ID3DXBuffer *psbuffer = NULL;
4663         ID3DXConstantTable *psconstanttable = NULL;
4664         int vsresult = 0;
4665         int psresult = 0;
4666         char temp[MAX_INPUTLINE];
4667         const char *vsversion = "vs_3_0", *psversion = "ps_3_0";
4668         qboolean debugshader = gl_paranoid.integer != 0;
4669         if (p->permutation & SHADERPERMUTATION_OFFSETMAPPING) {vsversion = "vs_3_0";psversion = "ps_3_0";}
4670         if (p->permutation & SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING) {vsversion = "vs_3_0";psversion = "ps_3_0";}
4671         if (!debugshader)
4672         {
4673                 vsbin = (DWORD *)FS_LoadFile(va("%s.vsbin", cachename), r_main_mempool, true, &vsbinsize);
4674                 psbin = (DWORD *)FS_LoadFile(va("%s.psbin", cachename), r_main_mempool, true, &psbinsize);
4675         }
4676         if ((!vsbin && vertstring) || (!psbin && fragstring))
4677         {
4678                 const char* dllnames_d3dx9 [] =
4679                 {
4680                         "d3dx9_43.dll",
4681                         "d3dx9_42.dll",
4682                         "d3dx9_41.dll",
4683                         "d3dx9_40.dll",
4684                         "d3dx9_39.dll",
4685                         "d3dx9_38.dll",
4686                         "d3dx9_37.dll",
4687                         "d3dx9_36.dll",
4688                         "d3dx9_35.dll",
4689                         "d3dx9_34.dll",
4690                         "d3dx9_33.dll",
4691                         "d3dx9_32.dll",
4692                         "d3dx9_31.dll",
4693                         "d3dx9_30.dll",
4694                         "d3dx9_29.dll",
4695                         "d3dx9_28.dll",
4696                         "d3dx9_27.dll",
4697                         "d3dx9_26.dll",
4698                         "d3dx9_25.dll",
4699                         "d3dx9_24.dll",
4700                         NULL
4701                 };
4702                 dllhandle_t d3dx9_dll = NULL;
4703                 HRESULT (WINAPI *qD3DXCompileShaderFromFileA)(LPCSTR pSrcFile, CONST D3DXMACRO* pDefines, LPD3DXINCLUDE pInclude, LPCSTR pFunctionName, LPCSTR pProfile, DWORD Flags, LPD3DXBUFFER* ppShader, LPD3DXBUFFER* ppErrorMsgs, LPD3DXCONSTANTTABLE* ppConstantTable);
4704                 HRESULT (WINAPI *qD3DXPreprocessShader)(LPCSTR pSrcData, UINT SrcDataSize, CONST D3DXMACRO* pDefines, LPD3DXINCLUDE pInclude, LPD3DXBUFFER* ppShaderText, LPD3DXBUFFER* ppErrorMsgs);
4705                 HRESULT (WINAPI *qD3DXCompileShader)(LPCSTR pSrcData, UINT SrcDataLen, CONST D3DXMACRO* pDefines, LPD3DXINCLUDE pInclude, LPCSTR pFunctionName, LPCSTR pProfile, DWORD Flags, LPD3DXBUFFER* ppShader, LPD3DXBUFFER* ppErrorMsgs, LPD3DXCONSTANTTABLE* ppConstantTable);
4706                 dllfunction_t d3dx9_dllfuncs[] =
4707                 {
4708                         {"D3DXCompileShaderFromFileA",  (void **) &qD3DXCompileShaderFromFileA},
4709                         {"D3DXPreprocessShader",                (void **) &qD3DXPreprocessShader},
4710                         {"D3DXCompileShader",                   (void **) &qD3DXCompileShader},
4711                         {NULL, NULL}
4712                 };
4713                 if (Sys_LoadLibrary(dllnames_d3dx9, &d3dx9_dll, d3dx9_dllfuncs))
4714                 {
4715                         DWORD shaderflags = 0;
4716                         if (debugshader)
4717                                 shaderflags = D3DXSHADER_DEBUG | D3DXSHADER_SKIPOPTIMIZATION;
4718                         vsbin = (DWORD *)Mem_Realloc(tempmempool, vsbin, 0);
4719                         psbin = (DWORD *)Mem_Realloc(tempmempool, psbin, 0);
4720                         if (vertstring && vertstring[0])
4721                         {
4722                                 if (debugshader)
4723                                 {
4724 //                                      vsresult = qD3DXPreprocessShader(vertstring, strlen(vertstring), NULL, NULL, &vsbuffer, &vslog);
4725 //                                      FS_WriteFile(va("%s_vs.fx", cachename), vsbuffer->GetBufferPointer(), vsbuffer->GetBufferSize());
4726                                         FS_WriteFile(va("%s_vs.fx", cachename), vertstring, strlen(vertstring));
4727                                         vsresult = qD3DXCompileShaderFromFileA(va("%s/%s_vs.fx", fs_gamedir, cachename), NULL, NULL, "main", vsversion, shaderflags, &vsbuffer, &vslog, &vsconstanttable);
4728                                 }
4729                                 else
4730                                         vsresult = qD3DXCompileShader(vertstring, strlen(vertstring), NULL, NULL, "main", vsversion, shaderflags, &vsbuffer, &vslog, &vsconstanttable);
4731                                 if (vsbuffer)
4732                                 {
4733                                         vsbinsize = vsbuffer->GetBufferSize();
4734                                         vsbin = (DWORD *)Mem_Alloc(tempmempool, vsbinsize);
4735                                         memcpy(vsbin, vsbuffer->GetBufferPointer(), vsbinsize);
4736                                         vsbuffer->Release();
4737                                 }
4738                                 if (vslog)
4739                                 {
4740                                         strlcpy(temp, (const char *)vslog->GetBufferPointer(), min(sizeof(temp), vslog->GetBufferSize()));
4741                                         Con_Printf("HLSL vertex shader compile output for %s follows:\n%s\n", cachename, temp);
4742                                         vslog->Release();
4743                                 }
4744                         }
4745                         if (fragstring && fragstring[0])
4746                         {
4747                                 if (debugshader)
4748                                 {
4749 //                                      psresult = qD3DXPreprocessShader(fragstring, strlen(fragstring), NULL, NULL, &psbuffer, &pslog);
4750 //                                      FS_WriteFile(va("%s_ps.fx", cachename), psbuffer->GetBufferPointer(), psbuffer->GetBufferSize());
4751                                         FS_WriteFile(va("%s_ps.fx", cachename), fragstring, strlen(fragstring));
4752                                         psresult = qD3DXCompileShaderFromFileA(va("%s/%s_ps.fx", fs_gamedir, cachename), NULL, NULL, "main", psversion, shaderflags, &psbuffer, &pslog, &psconstanttable);
4753                                 }
4754                                 else
4755                                         psresult = qD3DXCompileShader(fragstring, strlen(fragstring), NULL, NULL, "main", psversion, shaderflags, &psbuffer, &pslog, &psconstanttable);
4756                                 if (psbuffer)
4757                                 {
4758                                         psbinsize = psbuffer->GetBufferSize();
4759                                         psbin = (DWORD *)Mem_Alloc(tempmempool, psbinsize);
4760                                         memcpy(psbin, psbuffer->GetBufferPointer(), psbinsize);
4761                                         psbuffer->Release();
4762                                 }
4763                                 if (pslog)
4764                                 {
4765                                         strlcpy(temp, (const char *)pslog->GetBufferPointer(), min(sizeof(temp), pslog->GetBufferSize()));
4766                                         Con_Printf("HLSL pixel shader compile output for %s follows:\n%s\n", cachename, temp);
4767                                         pslog->Release();
4768                                 }
4769                         }
4770                         Sys_UnloadLibrary(&d3dx9_dll);
4771                 }
4772                 else
4773                         Con_Printf("Unable to compile shader - D3DXCompileShader function not found\n");
4774         }
4775         if (vsbin && psbin)
4776         {
4777                 vsresult = IDirect3DDevice9_CreateVertexShader(vid_d3d9dev, vsbin, &p->vertexshader);
4778                 if (FAILED(vsresult))
4779                         Con_Printf("HLSL CreateVertexShader failed for %s (hresult = %8x)\n", cachename, vsresult);
4780                 psresult = IDirect3DDevice9_CreatePixelShader(vid_d3d9dev, psbin, &p->pixelshader);
4781                 if (FAILED(psresult))
4782                         Con_Printf("HLSL CreatePixelShader failed for %s (hresult = %8x)\n", cachename, psresult);
4783         }
4784         // free the shader data
4785         vsbin = (DWORD *)Mem_Realloc(tempmempool, vsbin, 0);
4786         psbin = (DWORD *)Mem_Realloc(tempmempool, psbin, 0);
4787 }
4788
4789 static void R_HLSL_CompilePermutation(r_hlsl_permutation_t *p, unsigned int mode, unsigned int permutation)
4790 {
4791         int i;
4792         shadermodeinfo_t *modeinfo = hlslshadermodeinfo + mode;
4793         int vertstring_length = 0;
4794         int geomstring_length = 0;
4795         int fragstring_length = 0;
4796         char *t;
4797         char *vertexstring, *geometrystring, *fragmentstring;
4798         char *vertstring, *geomstring, *fragstring;
4799         char permutationname[256];
4800         char cachename[256];
4801         int vertstrings_count = 0;
4802         int geomstrings_count = 0;
4803         int fragstrings_count = 0;
4804         const char *vertstrings_list[32+3+SHADERSTATICPARMS_COUNT+1];
4805         const char *geomstrings_list[32+3+SHADERSTATICPARMS_COUNT+1];
4806         const char *fragstrings_list[32+3+SHADERSTATICPARMS_COUNT+1];
4807
4808         if (p->compiled)
4809                 return;
4810         p->compiled = true;
4811         p->vertexshader = NULL;
4812         p->pixelshader = NULL;
4813
4814         permutationname[0] = 0;
4815         cachename[0] = 0;
4816         vertexstring   = R_HLSL_GetText(modeinfo->vertexfilename, true);
4817         geometrystring = R_HLSL_GetText(modeinfo->geometryfilename, false);
4818         fragmentstring = R_HLSL_GetText(modeinfo->fragmentfilename, false);
4819
4820         strlcat(permutationname, modeinfo->vertexfilename, sizeof(permutationname));
4821         strlcat(cachename, "hlsl/", sizeof(cachename));
4822
4823         // define HLSL so that the shader can tell apart the HLSL compiler and the Cg compiler
4824         vertstrings_count = 0;
4825         geomstrings_count = 0;
4826         fragstrings_count = 0;
4827         vertstrings_list[vertstrings_count++] = "#define HLSL\n";
4828         geomstrings_list[geomstrings_count++] = "#define HLSL\n";
4829         fragstrings_list[fragstrings_count++] = "#define HLSL\n";
4830
4831         // the first pretext is which type of shader to compile as
4832         // (later these will all be bound together as a program object)
4833         vertstrings_list[vertstrings_count++] = "#define VERTEX_SHADER\n";
4834         geomstrings_list[geomstrings_count++] = "#define GEOMETRY_SHADER\n";
4835         fragstrings_list[fragstrings_count++] = "#define FRAGMENT_SHADER\n";
4836
4837         // the second pretext is the mode (for example a light source)
4838         vertstrings_list[vertstrings_count++] = modeinfo->pretext;
4839         geomstrings_list[geomstrings_count++] = modeinfo->pretext;
4840         fragstrings_list[fragstrings_count++] = modeinfo->pretext;
4841         strlcat(permutationname, modeinfo->name, sizeof(permutationname));
4842         strlcat(cachename, modeinfo->name, sizeof(cachename));
4843
4844         // now add all the permutation pretexts
4845         for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
4846         {
4847                 if (permutation & (1<<i))
4848                 {
4849                         vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i].pretext;
4850                         geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i].pretext;
4851                         fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i].pretext;
4852                         strlcat(permutationname, shaderpermutationinfo[i].name, sizeof(permutationname));
4853                         strlcat(cachename, shaderpermutationinfo[i].name, sizeof(cachename));
4854                 }
4855                 else
4856                 {
4857                         // keep line numbers correct
4858                         vertstrings_list[vertstrings_count++] = "\n";
4859                         geomstrings_list[geomstrings_count++] = "\n";
4860                         fragstrings_list[fragstrings_count++] = "\n";
4861                 }
4862         }
4863
4864         // add static parms
4865         R_CompileShader_AddStaticParms(mode, permutation);
4866         memcpy(vertstrings_list + vertstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
4867         vertstrings_count += shaderstaticparms_count;
4868         memcpy(geomstrings_list + geomstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
4869         geomstrings_count += shaderstaticparms_count;
4870         memcpy(fragstrings_list + fragstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
4871         fragstrings_count += shaderstaticparms_count;
4872
4873         // replace spaces in the cachename with _ characters
4874         for (i = 0;cachename[i];i++)
4875                 if (cachename[i] == ' ')
4876                         cachename[i] = '_';
4877
4878         // now append the shader text itself
4879         vertstrings_list[vertstrings_count++] = vertexstring;
4880         geomstrings_list[geomstrings_count++] = geometrystring;
4881         fragstrings_list[fragstrings_count++] = fragmentstring;
4882
4883         // if any sources were NULL, clear the respective list
4884         if (!vertexstring)
4885                 vertstrings_count = 0;
4886         if (!geometrystring)
4887                 geomstrings_count = 0;
4888         if (!fragmentstring)
4889                 fragstrings_count = 0;
4890
4891         vertstring_length = 0;
4892         for (i = 0;i < vertstrings_count;i++)
4893                 vertstring_length += strlen(vertstrings_list[i]);
4894         vertstring = t = (char *)Mem_Alloc(tempmempool, vertstring_length + 1);
4895         for (i = 0;i < vertstrings_count;t += strlen(vertstrings_list[i]), i++)
4896                 memcpy(t, vertstrings_list[i], strlen(vertstrings_list[i]));
4897
4898         geomstring_length = 0;
4899         for (i = 0;i < geomstrings_count;i++)
4900                 geomstring_length += strlen(geomstrings_list[i]);
4901         geomstring = t = (char *)Mem_Alloc(tempmempool, geomstring_length + 1);
4902         for (i = 0;i < geomstrings_count;t += strlen(geomstrings_list[i]), i++)
4903                 memcpy(t, geomstrings_list[i], strlen(geomstrings_list[i]));
4904
4905         fragstring_length = 0;
4906         for (i = 0;i < fragstrings_count;i++)
4907                 fragstring_length += strlen(fragstrings_list[i]);
4908         fragstring = t = (char *)Mem_Alloc(tempmempool, fragstring_length + 1);
4909         for (i = 0;i < fragstrings_count;t += strlen(fragstrings_list[i]), i++)
4910                 memcpy(t, fragstrings_list[i], strlen(fragstrings_list[i]));
4911
4912         // try to load the cached shader, or generate one
4913         R_HLSL_CacheShader(p, cachename, vertstring, fragstring);
4914
4915         if ((p->vertexshader || !vertstring[0]) && (p->pixelshader || !fragstring[0]))
4916                 Con_DPrintf("^5HLSL shader %s compiled.\n", permutationname);
4917         else
4918                 Con_Printf("^1HLSL shader %s failed!  some features may not work properly.\n", permutationname);
4919
4920         // free the strings
4921         if (vertstring)
4922                 Mem_Free(vertstring);
4923         if (geomstring)
4924                 Mem_Free(geomstring);
4925         if (fragstring)
4926                 Mem_Free(fragstring);
4927         if (vertexstring)
4928                 Mem_Free(vertexstring);
4929         if (geometrystring)
4930                 Mem_Free(geometrystring);
4931         if (fragmentstring)
4932                 Mem_Free(fragmentstring);
4933 }
4934
4935 static inline void hlslVSSetParameter16f(D3DVSREGISTER_t r, const float *a) {IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, a, 4);}
4936 static inline void hlslVSSetParameter4fv(D3DVSREGISTER_t r, const float *a) {IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, a, 1);}
4937 static inline void hlslVSSetParameter4f(D3DVSREGISTER_t r, float x, float y, float z, float w) {float temp[4];Vector4Set(temp, x, y, z, w);IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, temp, 1);}
4938 static inline void hlslVSSetParameter3f(D3DVSREGISTER_t r, float x, float y, float z) {float temp[4];Vector4Set(temp, x, y, z, 0);IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, temp, 1);}
4939 static inline void hlslVSSetParameter2f(D3DVSREGISTER_t r, float x, float y) {float temp[4];Vector4Set(temp, x, y, 0, 0);IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, temp, 1);}
4940 static inline void hlslVSSetParameter1f(D3DVSREGISTER_t r, float x) {float temp[4];Vector4Set(temp, x, 0, 0, 0);IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, temp, 1);}
4941
4942 static inline void hlslPSSetParameter16f(D3DPSREGISTER_t r, const float *a) {IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, a, 4);}
4943 static inline void hlslPSSetParameter4fv(D3DPSREGISTER_t r, const float *a) {IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, a, 1);}
4944 static inline void hlslPSSetParameter4f(D3DPSREGISTER_t r, float x, float y, float z, float w) {float temp[4];Vector4Set(temp, x, y, z, w);IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, temp, 1);}
4945 static inline void hlslPSSetParameter3f(D3DPSREGISTER_t r, float x, float y, float z) {float temp[4];Vector4Set(temp, x, y, z, 0);IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, temp, 1);}
4946 static inline void hlslPSSetParameter2f(D3DPSREGISTER_t r, float x, float y) {float temp[4];Vector4Set(temp, x, y, 0, 0);IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, temp, 1);}
4947 static inline void hlslPSSetParameter1f(D3DPSREGISTER_t r, float x) {float temp[4];Vector4Set(temp, x, 0, 0, 0);IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, temp, 1);}
4948
4949 void R_SetupShader_SetPermutationHLSL(unsigned int mode, unsigned int permutation)
4950 {
4951         r_hlsl_permutation_t *perm = R_HLSL_FindPermutation(mode, permutation);
4952         if (r_hlsl_permutation != perm)
4953         {
4954                 r_hlsl_permutation = perm;
4955                 if (!r_hlsl_permutation->vertexshader && !r_hlsl_permutation->pixelshader)
4956                 {
4957                         if (!r_hlsl_permutation->compiled)
4958                                 R_HLSL_CompilePermutation(perm, mode, permutation);
4959                         if (!r_hlsl_permutation->vertexshader && !r_hlsl_permutation->pixelshader)
4960                         {
4961                                 // remove features until we find a valid permutation
4962                                 int i;
4963                                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
4964                                 {
4965                                         // reduce i more quickly whenever it would not remove any bits
4966                                         int j = 1<<(SHADERPERMUTATION_COUNT-1-i);
4967                                         if (!(permutation & j))
4968                                                 continue;
4969                                         permutation -= j;
4970                                         r_hlsl_permutation = R_HLSL_FindPermutation(mode, permutation);
4971                                         if (!r_hlsl_permutation->compiled)
4972                                                 R_HLSL_CompilePermutation(perm, mode, permutation);
4973                                         if (r_hlsl_permutation->vertexshader || r_hlsl_permutation->pixelshader)
4974                                                 break;
4975                                 }
4976                                 if (i >= SHADERPERMUTATION_COUNT)
4977                                 {
4978                                         //Con_Printf("Could not find a working Cg shader for permutation %s %s\n", shadermodeinfo[mode].vertexfilename, shadermodeinfo[mode].pretext);
4979                                         r_hlsl_permutation = R_HLSL_FindPermutation(mode, permutation);
4980                                         return; // no bit left to clear, entire mode is broken
4981                                 }
4982                         }
4983                 }
4984                 IDirect3DDevice9_SetVertexShader(vid_d3d9dev, r_hlsl_permutation->vertexshader);
4985                 IDirect3DDevice9_SetPixelShader(vid_d3d9dev, r_hlsl_permutation->pixelshader);
4986         }
4987         hlslVSSetParameter16f(D3DVSREGISTER_ModelViewProjectionMatrix, gl_modelviewprojection16f);
4988         hlslVSSetParameter16f(D3DVSREGISTER_ModelViewMatrix, gl_modelview16f);
4989         hlslPSSetParameter1f(D3DPSREGISTER_ClientTime, cl.time);
4990 }
4991 #endif
4992
4993 void R_GLSL_Restart_f(void)
4994 {
4995         unsigned int i, limit;
4996         if (glslshaderstring && glslshaderstring != builtinshaderstring)
4997                 Mem_Free(glslshaderstring);
4998         glslshaderstring = NULL;
4999         if (cgshaderstring && cgshaderstring != builtincgshaderstring)
5000                 Mem_Free(cgshaderstring);
5001         cgshaderstring = NULL;
5002         if (hlslshaderstring && hlslshaderstring != builtincgshaderstring)
5003                 Mem_Free(hlslshaderstring);
5004         hlslshaderstring = NULL;
5005         switch(vid.renderpath)
5006         {
5007         case RENDERPATH_D3D9:
5008 #ifdef SUPPORTD3D
5009                 {
5010                         r_hlsl_permutation_t *p;
5011                         r_hlsl_permutation = NULL;
5012 //                      cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
5013 //                      cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
5014 //                      cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
5015 //                      cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
5016                         limit = Mem_ExpandableArray_IndexRange(&r_hlsl_permutationarray);
5017                         for (i = 0;i < limit;i++)
5018                         {
5019                                 if ((p = (r_hlsl_permutation_t*)Mem_ExpandableArray_RecordAtIndex(&r_hlsl_permutationarray, i)))
5020                                 {
5021                                         if (p->vertexshader)
5022                                                 IDirect3DVertexShader9_Release(p->vertexshader);
5023                                         if (p->pixelshader)
5024                                                 IDirect3DPixelShader9_Release(p->pixelshader);
5025                                         Mem_ExpandableArray_FreeRecord(&r_hlsl_permutationarray, (void*)p);
5026                                 }
5027                         }
5028                         memset(r_hlsl_permutationhash, 0, sizeof(r_hlsl_permutationhash));
5029                 }
5030 #endif
5031                 break;
5032         case RENDERPATH_D3D10:
5033                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5034                 break;
5035         case RENDERPATH_D3D11:
5036                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5037                 break;
5038         case RENDERPATH_GL20:
5039                 {
5040                         r_glsl_permutation_t *p;
5041                         r_glsl_permutation = NULL;
5042                         limit = Mem_ExpandableArray_IndexRange(&r_glsl_permutationarray);
5043                         for (i = 0;i < limit;i++)
5044                         {
5045                                 if ((p = (r_glsl_permutation_t*)Mem_ExpandableArray_RecordAtIndex(&r_glsl_permutationarray, i)))
5046                                 {
5047                                         GL_Backend_FreeProgram(p->program);
5048                                         Mem_ExpandableArray_FreeRecord(&r_glsl_permutationarray, (void*)p);
5049                                 }
5050                         }
5051                         memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash));
5052                 }
5053                 break;
5054         case RENDERPATH_CGGL:
5055 #ifdef SUPPORTCG
5056                 {
5057                         r_cg_permutation_t *p;
5058                         r_cg_permutation = NULL;
5059                         cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
5060                         cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
5061                         cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
5062                         cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
5063                         limit = Mem_ExpandableArray_IndexRange(&r_cg_permutationarray);
5064                         for (i = 0;i < limit;i++)
5065                         {
5066                                 if ((p = (r_cg_permutation_t*)Mem_ExpandableArray_RecordAtIndex(&r_cg_permutationarray, i)))
5067                                 {
5068                                         if (p->vprogram)
5069                                                 cgDestroyProgram(p->vprogram);
5070                                         if (p->fprogram)
5071                                                 cgDestroyProgram(p->fprogram);
5072                                         Mem_ExpandableArray_FreeRecord(&r_cg_permutationarray, (void*)p);
5073                                 }
5074                         }
5075                         memset(r_cg_permutationhash, 0, sizeof(r_cg_permutationhash));
5076                 }
5077 #endif
5078                 break;
5079         case RENDERPATH_GL13:
5080         case RENDERPATH_GL11:
5081                 break;
5082         }
5083 }
5084
5085 void R_GLSL_DumpShader_f(void)
5086 {
5087         int i;
5088         qfile_t *file;
5089
5090         file = FS_OpenRealFile("glsl/default.glsl", "w", false);
5091         if (file)
5092         {
5093                 FS_Print(file, "/* The engine may define the following macros:\n");
5094                 FS_Print(file, "#define VERTEX_SHADER\n#define GEOMETRY_SHADER\n#define FRAGMENT_SHADER\n");
5095                 for (i = 0;i < SHADERMODE_COUNT;i++)
5096                         FS_Print(file, glslshadermodeinfo[i].pretext);
5097                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
5098                         FS_Print(file, shaderpermutationinfo[i].pretext);
5099                 FS_Print(file, "*/\n");
5100                 FS_Print(file, builtinshaderstring);
5101                 FS_Close(file);
5102                 Con_Printf("glsl/default.glsl written\n");
5103         }
5104         else
5105                 Con_Printf("failed to write to glsl/default.glsl\n");
5106
5107 #ifdef SUPPORTCG
5108         file = FS_OpenRealFile("cg/default.cg", "w", false);
5109         if (file)
5110         {
5111                 FS_Print(file, "/* The engine may define the following macros:\n");
5112                 FS_Print(file, "#define VERTEX_SHADER\n#define GEOMETRY_SHADER\n#define FRAGMENT_SHADER\n");
5113                 for (i = 0;i < SHADERMODE_COUNT;i++)
5114                         FS_Print(file, cgshadermodeinfo[i].pretext);
5115                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
5116                         FS_Print(file, shaderpermutationinfo[i].pretext);
5117                 FS_Print(file, "*/\n");
5118                 FS_Print(file, builtincgshaderstring);
5119                 FS_Close(file);
5120                 Con_Printf("cg/default.cg written\n");
5121         }
5122         else
5123                 Con_Printf("failed to write to cg/default.cg\n");
5124 #endif
5125
5126 #ifdef SUPPORTD3D
5127         file = FS_OpenRealFile("hlsl/default.hlsl", "w", false);
5128         if (file)
5129         {
5130                 FS_Print(file, "/* The engine may define the following macros:\n");
5131                 FS_Print(file, "#define VERTEX_SHADER\n#define GEOMETRY_SHADER\n#define FRAGMENT_SHADER\n");
5132                 for (i = 0;i < SHADERMODE_COUNT;i++)
5133                         FS_Print(file, hlslshadermodeinfo[i].pretext);
5134                 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
5135                         FS_Print(file, shaderpermutationinfo[i].pretext);
5136                 FS_Print(file, "*/\n");
5137                 FS_Print(file, builtincgshaderstring);
5138                 FS_Close(file);
5139                 Con_Printf("hlsl/default.hlsl written\n");
5140         }
5141         else
5142                 Con_Printf("failed to write to hlsl/default.hlsl\n");
5143 #endif
5144 }
5145
5146 void R_SetupShader_Generic(rtexture_t *first, rtexture_t *second, int texturemode, int rgbscale)
5147 {
5148         if (!second)
5149                 texturemode = GL_MODULATE;
5150         switch (vid.renderpath)
5151         {
5152         case RENDERPATH_D3D9:
5153 #ifdef SUPPORTD3D
5154                 R_SetupShader_SetPermutationHLSL(SHADERMODE_GENERIC, SHADERPERMUTATION_VIEWTINT | (first ? SHADERPERMUTATION_DIFFUSE : 0) | (second ? SHADERPERMUTATION_SPECULAR : 0) | (texturemode == GL_MODULATE ? SHADERPERMUTATION_COLORMAPPING : (texturemode == GL_ADD ? SHADERPERMUTATION_GLOW : (texturemode == GL_DECAL ? SHADERPERMUTATION_VERTEXTEXTUREBLEND : 0))));
5155                 R_Mesh_TexBind(GL20TU_FIRST , first );
5156                 R_Mesh_TexBind(GL20TU_SECOND, second);
5157 #endif
5158                 break;
5159         case RENDERPATH_D3D10:
5160                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5161                 break;
5162         case RENDERPATH_D3D11:
5163                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5164                 break;
5165         case RENDERPATH_GL20:
5166                 R_SetupShader_SetPermutationGLSL(SHADERMODE_GENERIC, SHADERPERMUTATION_VIEWTINT | (first ? SHADERPERMUTATION_DIFFUSE : 0) | (second ? SHADERPERMUTATION_SPECULAR : 0) | (texturemode == GL_MODULATE ? SHADERPERMUTATION_COLORMAPPING : (texturemode == GL_ADD ? SHADERPERMUTATION_GLOW : (texturemode == GL_DECAL ? SHADERPERMUTATION_VERTEXTEXTUREBLEND : 0))));
5167                 R_Mesh_TexBind(GL20TU_FIRST , first );
5168                 R_Mesh_TexBind(GL20TU_SECOND, second);
5169                 break;
5170         case RENDERPATH_CGGL:
5171 #ifdef SUPPORTCG
5172                 CHECKCGERROR
5173                 R_SetupShader_SetPermutationCG(SHADERMODE_GENERIC, SHADERPERMUTATION_VIEWTINT | (first ? SHADERPERMUTATION_DIFFUSE : 0) | (second ? SHADERPERMUTATION_SPECULAR : 0) | (texturemode == GL_MODULATE ? SHADERPERMUTATION_COLORMAPPING : (texturemode == GL_ADD ? SHADERPERMUTATION_GLOW : (texturemode == GL_DECAL ? SHADERPERMUTATION_VERTEXTEXTUREBLEND : 0))));
5174                 if (r_cg_permutation->fp_Texture_First ) CG_BindTexture(r_cg_permutation->fp_Texture_First , first );CHECKCGERROR
5175                 if (r_cg_permutation->fp_Texture_Second) CG_BindTexture(r_cg_permutation->fp_Texture_Second, second);CHECKCGERROR
5176 #endif
5177                 break;
5178         case RENDERPATH_GL13:
5179                 R_Mesh_TexBind(0, first );
5180                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
5181                 R_Mesh_TexBind(1, second);
5182                 if (second)
5183                         R_Mesh_TexCombine(1, texturemode, texturemode, rgbscale, 1);
5184                 break;
5185         case RENDERPATH_GL11:
5186                 R_Mesh_TexBind(0, first );
5187                 break;
5188         }
5189 }
5190
5191 void R_SetupShader_DepthOrShadow(void)
5192 {
5193         switch (vid.renderpath)
5194         {
5195         case RENDERPATH_D3D9:
5196 #ifdef SUPPORTD3D
5197                 R_SetupShader_SetPermutationHLSL(SHADERMODE_DEPTH_OR_SHADOW, 0);
5198 #endif
5199                 break;
5200         case RENDERPATH_D3D10:
5201                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5202                 break;
5203         case RENDERPATH_D3D11:
5204                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5205                 break;
5206         case RENDERPATH_GL20:
5207                 R_SetupShader_SetPermutationGLSL(SHADERMODE_DEPTH_OR_SHADOW, 0);
5208                 break;
5209         case RENDERPATH_CGGL:
5210 #ifdef SUPPORTCG
5211                 R_SetupShader_SetPermutationCG(SHADERMODE_DEPTH_OR_SHADOW, 0);
5212 #endif
5213                 break;
5214         case RENDERPATH_GL13:
5215                 R_Mesh_TexBind(0, 0);
5216                 R_Mesh_TexBind(1, 0);
5217                 break;
5218         case RENDERPATH_GL11:
5219                 R_Mesh_TexBind(0, 0);
5220                 break;
5221         }
5222 }
5223
5224 void R_SetupShader_ShowDepth(void)
5225 {
5226         switch (vid.renderpath)
5227         {
5228         case RENDERPATH_D3D9:
5229 #ifdef SUPPORTHLSL
5230                 R_SetupShader_SetPermutationHLSL(SHADERMODE_SHOWDEPTH, 0);
5231 #endif
5232                 break;
5233         case RENDERPATH_D3D10:
5234                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5235                 break;
5236         case RENDERPATH_D3D11:
5237                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5238                 break;
5239         case RENDERPATH_GL20:
5240                 R_SetupShader_SetPermutationGLSL(SHADERMODE_SHOWDEPTH, 0);
5241                 break;
5242         case RENDERPATH_CGGL:
5243 #ifdef SUPPORTCG
5244                 R_SetupShader_SetPermutationCG(SHADERMODE_SHOWDEPTH, 0);
5245 #endif
5246                 break;
5247         case RENDERPATH_GL13:
5248                 break;
5249         case RENDERPATH_GL11:
5250                 break;
5251         }
5252 }
5253
5254 extern qboolean r_shadow_usingdeferredprepass;
5255 extern cvar_t r_shadow_deferred_8bitrange;
5256 extern rtexture_t *r_shadow_attenuationgradienttexture;
5257 extern rtexture_t *r_shadow_attenuation2dtexture;
5258 extern rtexture_t *r_shadow_attenuation3dtexture;
5259 extern qboolean r_shadow_usingshadowmap2d;
5260 extern qboolean r_shadow_usingshadowmaportho;
5261 extern float r_shadow_shadowmap_texturescale[2];
5262 extern float r_shadow_shadowmap_parameters[4];
5263 extern qboolean r_shadow_shadowmapvsdct;
5264 extern qboolean r_shadow_shadowmapsampler;
5265 extern int r_shadow_shadowmappcf;
5266 extern rtexture_t *r_shadow_shadowmap2dtexture;
5267 extern rtexture_t *r_shadow_shadowmap2dcolortexture;
5268 extern rtexture_t *r_shadow_shadowmapvsdcttexture;
5269 extern matrix4x4_t r_shadow_shadowmapmatrix;
5270 extern int r_shadow_shadowmaplod; // changes for each light based on distance
5271 extern int r_shadow_prepass_width;
5272 extern int r_shadow_prepass_height;
5273 extern rtexture_t *r_shadow_prepassgeometrydepthtexture;
5274 extern rtexture_t *r_shadow_prepassgeometrynormalmaptexture;
5275 extern rtexture_t *r_shadow_prepassgeometrydepthcolortexture;
5276 extern rtexture_t *r_shadow_prepasslightingdiffusetexture;
5277 extern rtexture_t *r_shadow_prepasslightingspeculartexture;
5278 extern cvar_t gl_mesh_separatearrays;
5279 static qboolean R_BlendFuncAllowsColormod(int src, int dst)
5280 {
5281         // a blendfunc allows colormod if:
5282         // a) it can never keep the destination pixel invariant, or
5283         // b) it can keep the destination pixel invariant, and still can do so if colormodded
5284         // this is to prevent unintended side effects from colormod
5285
5286         // in formulas:
5287         // IF there is a (s, sa) for which for all (d, da),
5288         //   s * src(s, d, sa, da) + d * dst(s, d, sa, da) == d
5289         // THEN, for this (s, sa) and all (colormod, d, da):
5290         //   s*colormod * src(s*colormod, d, sa, da) + d * dst(s*colormod, d, sa, da) == d
5291         // OBVIOUSLY, this means that
5292         //   s*colormod * src(s*colormod, d, sa, da) = 0
5293         //   dst(s*colormod, d, sa, da)              = 1
5294
5295         // note: not caring about GL_SRC_ALPHA_SATURATE and following here, these are unused in DP code
5296
5297         // main condition to leave dst color invariant:
5298         //   s * src(s, d, sa, da) + d * dst(s, d, sa, da) == d
5299         //   src == GL_ZERO:
5300         //     s * 0 + d * dst(s, d, sa, da) == d
5301         //       => dst == GL_ONE/GL_SRC_COLOR/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
5302         //       => colormod is a problem for GL_SRC_COLOR only
5303         //   src == GL_ONE:
5304         //     s + d * dst(s, d, sa, da) == d
5305         //       => s == 0
5306         //       => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
5307         //       => colormod is never problematic for these
5308         //   src == GL_SRC_COLOR:
5309         //     s*s + d * dst(s, d, sa, da) == d
5310         //       => s == 0
5311         //       => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
5312         //       => colormod is never problematic for these
5313         //   src == GL_ONE_MINUS_SRC_COLOR:
5314         //     s*(1-s) + d * dst(s, d, sa, da) == d
5315         //       => s == 0 or s == 1
5316         //       => dst == GL_ONE/GL_SRC_COLOR/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
5317         //       => colormod is a problem for GL_SRC_COLOR only
5318         //   src == GL_DST_COLOR
5319         //     s*d + d * dst(s, d, sa, da) == d
5320         //       => s == 1
5321         //       => dst == GL_ZERO/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
5322         //       => colormod is always a problem
5323         //     or
5324         //       => s == 0
5325         //       => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
5326         //       => colormod is never problematic for these
5327         //       => BUT, we do not know s! We must assume it is problematic
5328         //       then... except in GL_ONE case, where we know all invariant
5329         //       cases are fine
5330         //   src == GL_ONE_MINUS_DST_COLOR
5331         //     s*(1-d) + d * dst(s, d, sa, da) == d
5332         //       => s == 0 (1-d is impossible to handle for our desired result)
5333         //       => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
5334         //       => colormod is never problematic for these
5335         //   src == GL_SRC_ALPHA
5336         //     s*sa + d * dst(s, d, sa, da) == d
5337         //       => s == 0, or sa == 0
5338         //       => dst == GL_ONE/GL_SRC_COLOR/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
5339         //       => colormod breaks in the case GL_SRC_COLOR only
5340         //   src == GL_ONE_MINUS_SRC_ALPHA
5341         //     s*(1-sa) + d * dst(s, d, sa, da) == d
5342         //       => s == 0, or sa == 1
5343         //       => dst == GL_ONE/GL_SRC_COLOR/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
5344         //       => colormod breaks in the case GL_SRC_COLOR only
5345         //   src == GL_DST_ALPHA
5346         //     s*da + d * dst(s, d, sa, da) == d
5347         //       => s == 0
5348         //       => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA
5349         //       => colormod is never problematic for these
5350
5351         switch(src)
5352         {
5353                 case GL_ZERO:
5354                 case GL_ONE_MINUS_SRC_COLOR:
5355                 case GL_SRC_ALPHA:
5356                 case GL_ONE_MINUS_SRC_ALPHA:
5357                         if(dst == GL_SRC_COLOR)
5358                                 return false;
5359                         return true;
5360                 case GL_ONE:
5361                 case GL_SRC_COLOR:
5362                 case GL_ONE_MINUS_DST_COLOR:
5363                 case GL_DST_ALPHA:
5364                 case GL_ONE_MINUS_DST_ALPHA:
5365                         return true;
5366                 case GL_DST_COLOR:
5367                         if(dst == GL_ONE)
5368                                 return true;
5369                         return false;
5370                 default:
5371                         return false;
5372         }
5373 }
5374 void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, float ambientscale, float diffusescale, float specularscale, rsurfacepass_t rsurfacepass, int texturenumsurfaces, const msurface_t **texturesurfacelist, void *surfacewaterplane)
5375 {
5376         // select a permutation of the lighting shader appropriate to this
5377         // combination of texture, entity, light source, and fogging, only use the
5378         // minimum features necessary to avoid wasting rendering time in the
5379         // fragment shader on features that are not being used
5380         unsigned int permutation = 0;
5381         unsigned int mode = 0;
5382         qboolean allow_colormod;
5383         static float dummy_colormod[3] = {1, 1, 1};
5384         float *colormod = rsurface.colormod;
5385         float m16f[16];
5386         r_waterstate_waterplane_t *waterplane = (r_waterstate_waterplane_t *)surfacewaterplane;
5387         if (rsurfacepass == RSURFPASS_BACKGROUND)
5388         {
5389                 // distorted background
5390                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
5391                 {
5392                         mode = SHADERMODE_WATER;
5393                         if (rsurface.texture->r_water_waterscroll[0] && rsurface.texture->r_water_waterscroll[1])
5394                                 permutation |= SHADERPERMUTATION_NORMALMAPSCROLLBLEND;
5395                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5396                         allow_colormod = R_BlendFuncAllowsColormod(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5397                 }
5398                 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFRACTION)
5399                 {
5400                         mode = SHADERMODE_REFRACTION;
5401                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5402                         allow_colormod = R_BlendFuncAllowsColormod(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5403                 }
5404                 else
5405                 {
5406                         mode = SHADERMODE_GENERIC;
5407                         permutation |= SHADERPERMUTATION_DIFFUSE;
5408                         GL_BlendFunc(GL_ONE, GL_ZERO);
5409                         allow_colormod = R_BlendFuncAllowsColormod(GL_ONE, GL_ZERO);
5410                 }
5411                 GL_AlphaTest(false);
5412         }
5413         else if (rsurfacepass == RSURFPASS_DEFERREDGEOMETRY)
5414         {
5415                 if (r_glsl_offsetmapping.integer)
5416                 {
5417                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
5418                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5419                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
5420                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5421                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
5422                         {
5423                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5424                                 if (r_glsl_offsetmapping_reliefmapping.integer)
5425                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5426                         }
5427                 }
5428                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
5429                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
5430                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5431                         permutation |= SHADERPERMUTATION_ALPHAKILL;
5432                 // normalmap (deferred prepass), may use alpha test on diffuse
5433                 mode = SHADERMODE_DEFERREDGEOMETRY;
5434                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
5435                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
5436                 GL_AlphaTest(false);
5437                 GL_BlendFunc(GL_ONE, GL_ZERO);
5438                 allow_colormod = R_BlendFuncAllowsColormod(GL_ONE, GL_ZERO);
5439         }
5440         else if (rsurfacepass == RSURFPASS_RTLIGHT)
5441         {
5442                 if (r_glsl_offsetmapping.integer)
5443                 {
5444                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
5445                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5446                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
5447                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5448                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
5449                         {
5450                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5451                                 if (r_glsl_offsetmapping_reliefmapping.integer)
5452                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5453                         }
5454                 }
5455                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
5456                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
5457                 // light source
5458                 mode = SHADERMODE_LIGHTSOURCE;
5459                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
5460                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
5461                 if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
5462                         permutation |= SHADERPERMUTATION_CUBEFILTER;
5463                 if (diffusescale > 0)
5464                         permutation |= SHADERPERMUTATION_DIFFUSE;
5465                 if (specularscale > 0)
5466                         permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
5467                 if (r_refdef.fogenabled)
5468                         permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
5469                 if (rsurface.texture->colormapping)
5470                         permutation |= SHADERPERMUTATION_COLORMAPPING;
5471                 if (r_shadow_usingshadowmap2d)
5472                 {
5473                         permutation |= SHADERPERMUTATION_SHADOWMAP2D;
5474                         if(r_shadow_shadowmapvsdct)
5475                                 permutation |= SHADERPERMUTATION_SHADOWMAPVSDCT;
5476
5477                         if (r_shadow_shadowmapsampler)
5478                                 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
5479                         if (r_shadow_shadowmappcf > 1)
5480                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
5481                         else if (r_shadow_shadowmappcf)
5482                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
5483                 }
5484                 if (rsurface.texture->reflectmasktexture)
5485                         permutation |= SHADERPERMUTATION_REFLECTCUBE;
5486                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5487                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
5488                 allow_colormod = R_BlendFuncAllowsColormod(GL_SRC_ALPHA, GL_ONE);
5489         }
5490         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
5491         {
5492                 if (r_glsl_offsetmapping.integer)
5493                 {
5494                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
5495                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5496                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
5497                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5498                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
5499                         {
5500                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5501                                 if (r_glsl_offsetmapping_reliefmapping.integer)
5502                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5503                         }
5504                 }
5505                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
5506                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
5507                 // unshaded geometry (fullbright or ambient model lighting)
5508                 mode = SHADERMODE_FLATCOLOR;
5509                 ambientscale = diffusescale = specularscale = 0;
5510                 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
5511                         permutation |= SHADERPERMUTATION_GLOW;
5512                 if (r_refdef.fogenabled)
5513                         permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
5514                 if (rsurface.texture->colormapping)
5515                         permutation |= SHADERPERMUTATION_COLORMAPPING;
5516                 if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
5517                 {
5518                         permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
5519                         permutation |= SHADERPERMUTATION_SHADOWMAP2D;
5520
5521                         if (r_shadow_shadowmapsampler)
5522                                 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
5523                         if (r_shadow_shadowmappcf > 1)
5524                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
5525                         else if (r_shadow_shadowmappcf)
5526                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
5527                 }
5528                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
5529                         permutation |= SHADERPERMUTATION_REFLECTION;
5530                 if (rsurface.texture->reflectmasktexture)
5531                         permutation |= SHADERPERMUTATION_REFLECTCUBE;
5532                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5533                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5534                 allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5535         }
5536         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT_DIRECTIONAL)
5537         {
5538                 if (r_glsl_offsetmapping.integer)
5539                 {
5540                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
5541                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5542                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
5543                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5544                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
5545                         {
5546                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5547                                 if (r_glsl_offsetmapping_reliefmapping.integer)
5548                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5549                         }
5550                 }
5551                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
5552                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
5553                 // directional model lighting
5554                 mode = SHADERMODE_LIGHTDIRECTION;
5555                 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
5556                         permutation |= SHADERPERMUTATION_GLOW;
5557                 permutation |= SHADERPERMUTATION_DIFFUSE;
5558                 if (specularscale > 0)
5559                         permutation |= SHADERPERMUTATION_SPECULAR;
5560                 if (r_refdef.fogenabled)
5561                         permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
5562                 if (rsurface.texture->colormapping)
5563                         permutation |= SHADERPERMUTATION_COLORMAPPING;
5564                 if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
5565                 {
5566                         permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
5567                         permutation |= SHADERPERMUTATION_SHADOWMAP2D;
5568
5569                         if (r_shadow_shadowmapsampler)
5570                                 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
5571                         if (r_shadow_shadowmappcf > 1)
5572                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
5573                         else if (r_shadow_shadowmappcf)
5574                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
5575                 }
5576                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
5577                         permutation |= SHADERPERMUTATION_REFLECTION;
5578                 if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED))
5579                         permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
5580                 if (rsurface.texture->reflectmasktexture)
5581                         permutation |= SHADERPERMUTATION_REFLECTCUBE;
5582                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5583                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5584                 allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5585         }
5586         else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
5587         {
5588                 if (r_glsl_offsetmapping.integer)
5589                 {
5590                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
5591                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5592                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
5593                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5594                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
5595                         {
5596                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5597                                 if (r_glsl_offsetmapping_reliefmapping.integer)
5598                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5599                         }
5600                 }
5601                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
5602                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
5603                 // ambient model lighting
5604                 mode = SHADERMODE_LIGHTDIRECTION;
5605                 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
5606                         permutation |= SHADERPERMUTATION_GLOW;
5607                 if (r_refdef.fogenabled)
5608                         permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
5609                 if (rsurface.texture->colormapping)
5610                         permutation |= SHADERPERMUTATION_COLORMAPPING;
5611                 if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
5612                 {
5613                         permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
5614                         permutation |= SHADERPERMUTATION_SHADOWMAP2D;
5615
5616                         if (r_shadow_shadowmapsampler)
5617                                 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
5618                         if (r_shadow_shadowmappcf > 1)
5619                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
5620                         else if (r_shadow_shadowmappcf)
5621                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
5622                 }
5623                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
5624                         permutation |= SHADERPERMUTATION_REFLECTION;
5625                 if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED))
5626                         permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
5627                 if (rsurface.texture->reflectmasktexture)
5628                         permutation |= SHADERPERMUTATION_REFLECTCUBE;
5629                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5630                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5631                 allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5632         }
5633         else
5634         {
5635                 if (r_glsl_offsetmapping.integer)
5636                 {
5637                         if (rsurface.texture->offsetmapping == OFFSETMAPPING_LINEAR)
5638                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5639                         else if (rsurface.texture->offsetmapping == OFFSETMAPPING_RELIEF)
5640                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5641                         else if (rsurface.texture->offsetmapping != OFFSETMAPPING_OFF)
5642                         {
5643                                 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
5644                                 if (r_glsl_offsetmapping_reliefmapping.integer)
5645                                         permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
5646                         }
5647                 }
5648                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
5649                         permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
5650                 // lightmapped wall
5651                 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
5652                         permutation |= SHADERPERMUTATION_GLOW;
5653                 if (r_refdef.fogenabled)
5654                         permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
5655                 if (rsurface.texture->colormapping)
5656                         permutation |= SHADERPERMUTATION_COLORMAPPING;
5657                 if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
5658                 {
5659                         permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
5660                         permutation |= SHADERPERMUTATION_SHADOWMAP2D;
5661
5662                         if (r_shadow_shadowmapsampler)
5663                                 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
5664                         if (r_shadow_shadowmappcf > 1)
5665                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
5666                         else if (r_shadow_shadowmappcf)
5667                                 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
5668                 }
5669                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
5670                         permutation |= SHADERPERMUTATION_REFLECTION;
5671                 if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED))
5672                         permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
5673                 if (rsurface.texture->reflectmasktexture)
5674                         permutation |= SHADERPERMUTATION_REFLECTCUBE;
5675                 if (FAKELIGHT_ENABLED)
5676                 {
5677                         // fake lightmapping (q1bsp, q3bsp, fullbright map)
5678                         mode = SHADERMODE_FAKELIGHT;
5679                         permutation |= SHADERPERMUTATION_DIFFUSE;
5680                         if (specularscale > 0)
5681                                 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
5682                 }
5683                 else if (r_glsl_deluxemapping.integer >= 1 && rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping)
5684                 {
5685                         // deluxemapping (light direction texture)
5686                         if (rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping && r_refdef.scene.worldmodel->brushq3.deluxemapping_modelspace)
5687                                 mode = SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE;
5688                         else
5689                                 mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
5690                         permutation |= SHADERPERMUTATION_DIFFUSE;
5691                         if (specularscale > 0)
5692                                 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
5693                 }
5694                 else if (r_glsl_deluxemapping.integer >= 2 && rsurface.uselightmaptexture)
5695                 {
5696                         // fake deluxemapping (uniform light direction in tangentspace)
5697                         mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
5698                         permutation |= SHADERPERMUTATION_DIFFUSE;
5699                         if (specularscale > 0)
5700                                 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
5701                 }
5702                 else if (rsurface.uselightmaptexture)
5703                 {
5704                         // ordinary lightmapping (q1bsp, q3bsp)
5705                         mode = SHADERMODE_LIGHTMAP;
5706                 }
5707                 else
5708                 {
5709                         // ordinary vertex coloring (q3bsp)
5710                         mode = SHADERMODE_VERTEXCOLOR;
5711                 }
5712                 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5713                 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5714                 allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5715         }
5716         if(!allow_colormod)
5717                 colormod = dummy_colormod;
5718         switch(vid.renderpath)
5719         {
5720         case RENDERPATH_D3D9:
5721 #ifdef SUPPORTD3D
5722                 RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | (rsurface.modellightmapcolor4f ? BATCHNEED_VERTEXMESH_VERTEXCOLOR : 0) | BATCHNEED_VERTEXMESH_TEXCOORD | (rsurface.uselightmaptexture ? BATCHNEED_VERTEXMESH_LIGHTMAP : 0), texturenumsurfaces, texturesurfacelist);
5723                 R_Mesh_PrepareVertices_Mesh(rsurface.batchnumvertices, rsurface.batchvertexmesh, rsurface.batchvertexmeshbuffer);
5724                 R_SetupShader_SetPermutationHLSL(mode, permutation);
5725                 Matrix4x4_ToArrayFloatGL(&rsurface.matrix, m16f);hlslPSSetParameter16f(D3DPSREGISTER_ModelToReflectCube, m16f);
5726                 if (mode == SHADERMODE_LIGHTSOURCE)
5727                 {
5728                         Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);hlslVSSetParameter16f(D3DVSREGISTER_ModelToLight, m16f);
5729                         hlslVSSetParameter3f(D3DVSREGISTER_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
5730                 }
5731                 else
5732                 {
5733                         if (mode == SHADERMODE_LIGHTDIRECTION)
5734                         {
5735                                 hlslVSSetParameter3f(D3DVSREGISTER_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);
5736                         }
5737                 }
5738                 Matrix4x4_ToArrayFloatGL(&rsurface.texture->currenttexmatrix, m16f);hlslVSSetParameter16f(D3DVSREGISTER_TexMatrix, m16f);
5739                 Matrix4x4_ToArrayFloatGL(&rsurface.texture->currentbackgroundtexmatrix, m16f);hlslVSSetParameter16f(D3DVSREGISTER_BackgroundTexMatrix, m16f);
5740                 Matrix4x4_ToArrayFloatGL(&r_shadow_shadowmapmatrix, m16f);hlslVSSetParameter16f(D3DVSREGISTER_ShadowMapMatrix, m16f);
5741                 hlslVSSetParameter3f(D3DVSREGISTER_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);
5742                 hlslVSSetParameter4f(D3DVSREGISTER_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]);
5743
5744                 if (mode == SHADERMODE_LIGHTSOURCE)
5745                 {
5746                         hlslPSSetParameter3f(D3DPSREGISTER_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
5747                         hlslPSSetParameter3f(D3DPSREGISTER_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);
5748                         hlslPSSetParameter3f(D3DPSREGISTER_Color_Ambient, colormod[0] * ambientscale, colormod[1] * ambientscale, colormod[2] * ambientscale);
5749                         hlslPSSetParameter3f(D3DPSREGISTER_Color_Diffuse, colormod[0] * diffusescale, colormod[1] * diffusescale, colormod[2] * diffusescale);
5750                         hlslPSSetParameter3f(D3DPSREGISTER_Color_Specular, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale);
5751
5752                         // additive passes are only darkened by fog, not tinted
5753                         hlslPSSetParameter3f(D3DPSREGISTER_FogColor, 0, 0, 0);
5754                         hlslPSSetParameter1f(D3DPSREGISTER_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f));
5755                 }
5756                 else
5757                 {
5758                         if (mode == SHADERMODE_FLATCOLOR)
5759                         {
5760                                 hlslPSSetParameter3f(D3DPSREGISTER_Color_Ambient, colormod[0], colormod[1], colormod[2]);
5761                         }
5762                         else if (mode == SHADERMODE_LIGHTDIRECTION)
5763                         {
5764                                 hlslPSSetParameter3f(D3DPSREGISTER_Color_Ambient, (r_refdef.scene.ambient + rsurface.modellight_ambient[0] * r_refdef.lightmapintensity) * colormod[0], (r_refdef.scene.ambient + rsurface.modellight_ambient[1] * r_refdef.lightmapintensity) * colormod[1], (r_refdef.scene.ambient + rsurface.modellight_ambient[2] * r_refdef.lightmapintensity) * colormod[2]);
5765                                 hlslPSSetParameter3f(D3DPSREGISTER_Color_Diffuse, r_refdef.lightmapintensity * colormod[0], r_refdef.lightmapintensity * colormod[1], r_refdef.lightmapintensity * colormod[2]);
5766                                 hlslPSSetParameter3f(D3DPSREGISTER_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale);
5767                                 hlslPSSetParameter3f(D3DPSREGISTER_DeferredMod_Diffuse, colormod[0] * r_shadow_deferred_8bitrange.value, colormod[1] * r_shadow_deferred_8bitrange.value, colormod[2] * r_shadow_deferred_8bitrange.value);
5768                                 hlslPSSetParameter3f(D3DPSREGISTER_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value);
5769                                 hlslPSSetParameter3f(D3DPSREGISTER_LightColor, rsurface.modellight_diffuse[0], rsurface.modellight_diffuse[1], rsurface.modellight_diffuse[2]);
5770                                 hlslPSSetParameter3f(D3DPSREGISTER_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);
5771                         }
5772                         else
5773                         {
5774                                 hlslPSSetParameter3f(D3DPSREGISTER_Color_Ambient, r_refdef.scene.ambient * colormod[0], r_refdef.scene.ambient * colormod[1], r_refdef.scene.ambient * colormod[2]);
5775                                 hlslPSSetParameter3f(D3DPSREGISTER_Color_Diffuse, rsurface.texture->lightmapcolor[0], rsurface.texture->lightmapcolor[1], rsurface.texture->lightmapcolor[2]);
5776                                 hlslPSSetParameter3f(D3DPSREGISTER_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale);
5777                                 hlslPSSetParameter3f(D3DPSREGISTER_DeferredMod_Diffuse, colormod[0] * diffusescale * r_shadow_deferred_8bitrange.value, colormod[1] * diffusescale * r_shadow_deferred_8bitrange.value, colormod[2] * diffusescale * r_shadow_deferred_8bitrange.value);
5778                                 hlslPSSetParameter3f(D3DPSREGISTER_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value);
5779                         }
5780                         // additive passes are only darkened by fog, not tinted
5781                         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
5782                                 hlslPSSetParameter3f(D3DPSREGISTER_FogColor, 0, 0, 0);
5783                         else
5784                                 hlslPSSetParameter3f(D3DPSREGISTER_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
5785                         hlslPSSetParameter4f(D3DPSREGISTER_DistortScaleRefractReflect, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor);
5786                         hlslPSSetParameter4f(D3DPSREGISTER_ScreenScaleRefractReflect, r_waterstate.screenscale[0], r_waterstate.screenscale[1], r_waterstate.screenscale[0], r_waterstate.screenscale[1]);
5787                         hlslPSSetParameter4f(D3DPSREGISTER_ScreenCenterRefractReflect, r_waterstate.screencenter[0], r_waterstate.screencenter[1], r_waterstate.screencenter[0], r_waterstate.screencenter[1]);
5788                         hlslPSSetParameter4f(D3DPSREGISTER_RefractColor, rsurface.texture->refractcolor4f[0], rsurface.texture->refractcolor4f[1], rsurface.texture->refractcolor4f[2], rsurface.texture->refractcolor4f[3] * rsurface.texture->lightmapcolor[3]);
5789                         hlslPSSetParameter4f(D3DPSREGISTER_ReflectColor, rsurface.texture->reflectcolor4f[0], rsurface.texture->reflectcolor4f[1], rsurface.texture->reflectcolor4f[2], rsurface.texture->reflectcolor4f[3] * rsurface.texture->lightmapcolor[3]);
5790                         hlslPSSetParameter1f(D3DPSREGISTER_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);
5791                         hlslPSSetParameter1f(D3DPSREGISTER_ReflectOffset, rsurface.texture->reflectmin);
5792                         hlslPSSetParameter1f(D3DPSREGISTER_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f));
5793                         if (mode == SHADERMODE_WATER)
5794                                 hlslPSSetParameter2f(D3DPSREGISTER_NormalmapScrollBlend, rsurface.texture->r_water_waterscroll[0], rsurface.texture->r_water_waterscroll[1]);
5795                 }
5796                 hlslPSSetParameter2f(D3DPSREGISTER_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);
5797                 hlslPSSetParameter4f(D3DPSREGISTER_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);
5798                 hlslPSSetParameter3f(D3DPSREGISTER_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]);
5799                 hlslPSSetParameter1f(D3DPSREGISTER_Alpha, rsurface.texture->lightmapcolor[3] * ((rsurface.texture->basematerialflags & MATERIALFLAG_WATERSHADER && r_waterstate.enabled && !r_refdef.view.isoverlay) ? rsurface.texture->r_water_wateralpha : 1));
5800                 hlslPSSetParameter3f(D3DPSREGISTER_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);
5801                 if (rsurface.texture->pantstexture)
5802                         hlslPSSetParameter3f(D3DPSREGISTER_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
5803                 else
5804                         hlslPSSetParameter3f(D3DPSREGISTER_Color_Pants, 0, 0, 0);
5805                 if (rsurface.texture->shirttexture)
5806                         hlslPSSetParameter3f(D3DPSREGISTER_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
5807                 else
5808                         hlslPSSetParameter3f(D3DPSREGISTER_Color_Shirt, 0, 0, 0);
5809                 hlslPSSetParameter4f(D3DPSREGISTER_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]);
5810                 hlslPSSetParameter1f(D3DPSREGISTER_FogPlaneViewDist, rsurface.fogplaneviewdist);
5811                 hlslPSSetParameter1f(D3DPSREGISTER_FogRangeRecip, rsurface.fograngerecip);
5812                 hlslPSSetParameter1f(D3DPSREGISTER_FogHeightFade, rsurface.fogheightfade);
5813                 hlslPSSetParameter1f(D3DPSREGISTER_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);
5814                 hlslPSSetParameter2f(D3DPSREGISTER_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);
5815                 hlslPSSetParameter2f(D3DPSREGISTER_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);
5816
5817                 R_Mesh_TexBind(GL20TU_NORMAL            , rsurface.texture->nmaptexture                       );
5818                 R_Mesh_TexBind(GL20TU_COLOR             , rsurface.texture->basetexture                       );
5819                 R_Mesh_TexBind(GL20TU_GLOSS             , rsurface.texture->glosstexture                      );
5820                 R_Mesh_TexBind(GL20TU_GLOW              , rsurface.texture->glowtexture                       );
5821                 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_NORMAL  , rsurface.texture->backgroundnmaptexture             );
5822                 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_COLOR   , rsurface.texture->backgroundbasetexture             );
5823                 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_GLOSS   , rsurface.texture->backgroundglosstexture            );
5824                 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_GLOW    , rsurface.texture->backgroundglowtexture             );
5825                 if (permutation & SHADERPERMUTATION_COLORMAPPING) R_Mesh_TexBind(GL20TU_PANTS             , rsurface.texture->pantstexture                      );
5826                 if (permutation & SHADERPERMUTATION_COLORMAPPING) R_Mesh_TexBind(GL20TU_SHIRT             , rsurface.texture->shirttexture                      );
5827                 if (permutation & SHADERPERMUTATION_REFLECTCUBE) R_Mesh_TexBind(GL20TU_REFLECTMASK       , rsurface.texture->reflectmasktexture                );
5828                 if (permutation & SHADERPERMUTATION_REFLECTCUBE) R_Mesh_TexBind(GL20TU_REFLECTCUBE       , rsurface.texture->reflectcubetexture ? rsurface.texture->reflectcubetexture : r_texture_whitecube);
5829                 if (permutation & SHADERPERMUTATION_FOGHEIGHTTEXTURE) R_Mesh_TexBind(GL20TU_FOGHEIGHTTEXTURE  , r_texture_fogheighttexture                          );
5830                 if (permutation & (SHADERPERMUTATION_FOGINSIDE | SHADERPERMUTATION_FOGOUTSIDE)) R_Mesh_TexBind(GL20TU_FOGMASK           , r_texture_fogattenuation                            );
5831                 R_Mesh_TexBind(GL20TU_LIGHTMAP          , rsurface.lightmaptexture ? rsurface.lightmaptexture : r_texture_white);
5832                 R_Mesh_TexBind(GL20TU_DELUXEMAP         , rsurface.deluxemaptexture ? rsurface.deluxemaptexture : r_texture_blanknormalmap);
5833                 if (rsurface.rtlight                                  ) R_Mesh_TexBind(GL20TU_ATTENUATION       , r_shadow_attenuationgradienttexture                 );
5834                 if (rsurfacepass == RSURFPASS_BACKGROUND)
5835                 {
5836                         R_Mesh_TexBind(GL20TU_REFRACTION        , waterplane->texture_refraction ? waterplane->texture_refraction : r_texture_black);
5837                         if(mode == SHADERMODE_GENERIC) R_Mesh_TexBind(GL20TU_FIRST             , waterplane->texture_camera ? waterplane->texture_camera : r_texture_black);
5838                         R_Mesh_TexBind(GL20TU_REFLECTION        , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);
5839                 }
5840                 else
5841                 {
5842                         if (permutation & SHADERPERMUTATION_REFLECTION        ) R_Mesh_TexBind(GL20TU_REFLECTION        , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);
5843                 }
5844 //              if (rsurfacepass == RSURFPASS_DEFERREDLIGHT           ) R_Mesh_TexBind(GL20TU_SCREENDEPTH       , r_shadow_prepassgeometrydepthtexture                );
5845 //              if (rsurfacepass == RSURFPASS_DEFERREDLIGHT           ) R_Mesh_TexBind(GL20TU_SCREENNORMALMAP   , r_shadow_prepassgeometrynormalmaptexture            );
5846                 if (permutation & SHADERPERMUTATION_DEFERREDLIGHTMAP  ) R_Mesh_TexBind(GL20TU_SCREENDIFFUSE     , r_shadow_prepasslightingdiffusetexture              );
5847                 if (permutation & SHADERPERMUTATION_DEFERREDLIGHTMAP  ) R_Mesh_TexBind(GL20TU_SCREENSPECULAR    , r_shadow_prepasslightingspeculartexture             );
5848                 if (rsurface.rtlight || (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW)))
5849                 {
5850                         R_Mesh_TexBind(GL20TU_SHADOWMAP2D, r_shadow_shadowmap2dcolortexture);
5851                         if (rsurface.rtlight)
5852                         {
5853                                 if (permutation & SHADERPERMUTATION_CUBEFILTER        ) R_Mesh_TexBind(GL20TU_CUBE              , rsurface.rtlight->currentcubemap                    );
5854                                 if (permutation & SHADERPERMUTATION_SHADOWMAPVSDCT    ) R_Mesh_TexBind(GL20TU_CUBEPROJECTION    , r_shadow_shadowmapvsdcttexture                      );
5855                         }
5856                 }
5857 #endif
5858                 break;
5859         case RENDERPATH_D3D10:
5860                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5861                 break;
5862         case RENDERPATH_D3D11:
5863                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5864                 break;
5865         case RENDERPATH_GL20:
5866                 if (gl_mesh_separatearrays.integer)
5867                 {
5868                         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | (rsurface.modellightmapcolor4f ? BATCHNEED_ARRAY_VERTEXCOLOR : 0) | BATCHNEED_ARRAY_TEXCOORD | (rsurface.uselightmaptexture ? BATCHNEED_ARRAY_LIGHTMAP : 0), texturenumsurfaces, texturesurfacelist);
5869                         R_Mesh_VertexPointer(     3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
5870                         R_Mesh_ColorPointer(      4, GL_FLOAT, sizeof(float[4]), rsurface.batchlightmapcolor4f, rsurface.batchlightmapcolor4f_vertexbuffer, rsurface.batchlightmapcolor4f_bufferoffset);
5871                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
5872                         R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchsvector3f, rsurface.batchsvector3f_vertexbuffer, rsurface.batchsvector3f_bufferoffset);
5873                         R_Mesh_TexCoordPointer(2, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchtvector3f, rsurface.batchtvector3f_vertexbuffer, rsurface.batchtvector3f_bufferoffset);
5874                         R_Mesh_TexCoordPointer(3, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchnormal3f, rsurface.batchnormal3f_vertexbuffer, rsurface.batchnormal3f_bufferoffset);
5875                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordlightmap2f_vertexbuffer, rsurface.batchtexcoordlightmap2f_bufferoffset);
5876                 }
5877                 else
5878                 {
5879                         RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | (rsurface.modellightmapcolor4f ? BATCHNEED_VERTEXMESH_VERTEXCOLOR : 0) | BATCHNEED_VERTEXMESH_TEXCOORD | (rsurface.uselightmaptexture ? BATCHNEED_VERTEXMESH_LIGHTMAP : 0), texturenumsurfaces, texturesurfacelist);
5880                         R_Mesh_PrepareVertices_Mesh(rsurface.batchnumvertices, rsurface.batchvertexmesh, rsurface.batchvertexmeshbuffer);
5881                 }
5882                 R_SetupShader_SetPermutationGLSL(mode, permutation);
5883                 if (r_glsl_permutation->loc_ModelToReflectCube >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.matrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelToReflectCube, 1, false, m16f);}
5884                 if (mode == SHADERMODE_LIGHTSOURCE)
5885                 {
5886                         if (r_glsl_permutation->loc_ModelToLight >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelToLight, 1, false, m16f);}
5887                         if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
5888                         if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);
5889                         if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, colormod[0] * ambientscale, colormod[1] * ambientscale, colormod[2] * ambientscale);
5890                         if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Diffuse, colormod[0] * diffusescale, colormod[1] * diffusescale, colormod[2] * diffusescale);
5891                         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);
5892
5893                         // additive passes are only darkened by fog, not tinted
5894                         if (r_glsl_permutation->loc_FogColor >= 0)
5895                                 qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
5896                         if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f));
5897                 }
5898                 else
5899                 {
5900                         if (mode == SHADERMODE_FLATCOLOR)
5901                         {
5902                                 if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, colormod[0], colormod[1], colormod[2]);
5903                         }
5904                         else if (mode == SHADERMODE_LIGHTDIRECTION)
5905                         {
5906                                 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 * r_refdef.scene.rtlightstylevalue[0]) * colormod[0], (r_refdef.scene.ambient + rsurface.modellight_ambient[1] * r_refdef.lightmapintensity * r_refdef.scene.rtlightstylevalue[0]) * colormod[1], (r_refdef.scene.ambient + rsurface.modellight_ambient[2] * r_refdef.lightmapintensity * r_refdef.scene.rtlightstylevalue[0]) * colormod[2]);
5907                                 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]);
5908                                 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);
5909                                 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);
5910                                 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);
5911                                 if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, rsurface.modellight_diffuse[0] * r_refdef.scene.rtlightstylevalue[0], rsurface.modellight_diffuse[1] * r_refdef.scene.rtlightstylevalue[0], rsurface.modellight_diffuse[2] * r_refdef.scene.rtlightstylevalue[0]);
5912                                 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]);
5913                         }
5914                         else
5915                         {
5916                                 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]);
5917                                 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]);
5918                                 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);
5919                                 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);
5920                                 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);
5921                         }
5922                         // additive passes are only darkened by fog, not tinted
5923                         if (r_glsl_permutation->loc_FogColor >= 0)
5924                         {
5925                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
5926                                         qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
5927                                 else
5928                                         qglUniform3fARB(r_glsl_permutation->loc_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
5929                         }
5930                         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);
5931                         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]);
5932                         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]);
5933                         if (r_glsl_permutation->loc_RefractColor >= 0) qglUniform4fARB(r_glsl_permutation->loc_RefractColor, rsurface.texture->refractcolor4f[0], rsurface.texture->refractcolor4f[1], rsurface.texture->refractcolor4f[2], rsurface.texture->refractcolor4f[3] * rsurface.texture->lightmapcolor[3]);
5934                         if (r_glsl_permutation->loc_ReflectColor >= 0) qglUniform4fARB(r_glsl_permutation->loc_ReflectColor, rsurface.texture->reflectcolor4f[0], rsurface.texture->reflectcolor4f[1], rsurface.texture->reflectcolor4f[2], rsurface.texture->reflectcolor4f[3] * rsurface.texture->lightmapcolor[3]);
5935                         if (r_glsl_permutation->loc_ReflectFactor >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);
5936                         if (r_glsl_permutation->loc_ReflectOffset >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectOffset, rsurface.texture->reflectmin);
5937                         if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f));
5938                         if (r_glsl_permutation->loc_NormalmapScrollBlend >= 0) qglUniform2fARB(r_glsl_permutation->loc_NormalmapScrollBlend, rsurface.texture->r_water_waterscroll[0], rsurface.texture->r_water_waterscroll[1]);
5939                 }
5940                 if (r_glsl_permutation->loc_TexMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currenttexmatrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_TexMatrix, 1, false, m16f);}
5941                 if (r_glsl_permutation->loc_BackgroundTexMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currentbackgroundtexmatrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_BackgroundTexMatrix, 1, false, m16f);}
5942                 if (r_glsl_permutation->loc_ShadowMapMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&r_shadow_shadowmapmatrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_ShadowMapMatrix, 1, false, m16f);}
5943                 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]);
5944                 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]);
5945
5946                 if (r_glsl_permutation->loc_Color_Glow >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]);
5947                 if (r_glsl_permutation->loc_Alpha >= 0) qglUniform1fARB(r_glsl_permutation->loc_Alpha, rsurface.texture->lightmapcolor[3] * ((rsurface.texture->basematerialflags & MATERIALFLAG_WATERSHADER && r_waterstate.enabled && !r_refdef.view.isoverlay) ? rsurface.texture->r_water_wateralpha : 1));
5948                 if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);
5949                 if (r_glsl_permutation->loc_Color_Pants >= 0)
5950                 {
5951                         if (rsurface.texture->pantstexture)
5952                                 qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
5953                         else
5954                                 qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, 0, 0, 0);
5955                 }
5956                 if (r_glsl_permutation->loc_Color_Shirt >= 0)
5957                 {
5958                         if (rsurface.texture->shirttexture)
5959                                 qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
5960                         else
5961                                 qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, 0, 0, 0);
5962                 }
5963                 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]);
5964                 if (r_glsl_permutation->loc_FogPlaneViewDist >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogPlaneViewDist, rsurface.fogplaneviewdist);
5965                 if (r_glsl_permutation->loc_FogRangeRecip >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogRangeRecip, rsurface.fograngerecip);
5966                 if (r_glsl_permutation->loc_FogHeightFade >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogHeightFade, rsurface.fogheightfade);
5967                 if (r_glsl_permutation->loc_OffsetMapping_Scale >= 0) qglUniform1fARB(r_glsl_permutation->loc_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value*rsurface.texture->offsetscale);
5968                 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]);
5969                 if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
5970
5971         //      if (r_glsl_permutation->loc_Texture_First           >= 0) R_Mesh_TexBind(GL20TU_FIRST             , r_texture_white                                     );
5972         //      if (r_glsl_permutation->loc_Texture_Second          >= 0) R_Mesh_TexBind(GL20TU_SECOND            , r_texture_white                                     );
5973         //      if (r_glsl_permutation->loc_Texture_GammaRamps      >= 0) R_Mesh_TexBind(GL20TU_GAMMARAMPS        , r_texture_gammaramps                                );
5974                 if (r_glsl_permutation->loc_Texture_Normal          >= 0) R_Mesh_TexBind(GL20TU_NORMAL            , rsurface.texture->nmaptexture                       );
5975                 if (r_glsl_permutation->loc_Texture_Color           >= 0) R_Mesh_TexBind(GL20TU_COLOR             , rsurface.texture->basetexture                       );
5976                 if (r_glsl_permutation->loc_Texture_Gloss           >= 0) R_Mesh_TexBind(GL20TU_GLOSS             , rsurface.texture->glosstexture                      );
5977                 if (r_glsl_permutation->loc_Texture_Glow            >= 0) R_Mesh_TexBind(GL20TU_GLOW              , rsurface.texture->glowtexture                       );
5978                 if (r_glsl_permutation->loc_Texture_SecondaryNormal >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_NORMAL  , rsurface.texture->backgroundnmaptexture             );
5979                 if (r_glsl_permutation->loc_Texture_SecondaryColor  >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_COLOR   , rsurface.texture->backgroundbasetexture             );
5980                 if (r_glsl_permutation->loc_Texture_SecondaryGloss  >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_GLOSS   , rsurface.texture->backgroundglosstexture            );
5981                 if (r_glsl_permutation->loc_Texture_SecondaryGlow   >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_GLOW    , rsurface.texture->backgroundglowtexture             );
5982                 if (r_glsl_permutation->loc_Texture_Pants           >= 0) R_Mesh_TexBind(GL20TU_PANTS             , rsurface.texture->pantstexture                      );
5983                 if (r_glsl_permutation->loc_Texture_Shirt           >= 0) R_Mesh_TexBind(GL20TU_SHIRT             , rsurface.texture->shirttexture                      );
5984                 if (r_glsl_permutation->loc_Texture_ReflectMask     >= 0) R_Mesh_TexBind(GL20TU_REFLECTMASK       , rsurface.texture->reflectmasktexture                );
5985                 if (r_glsl_permutation->loc_Texture_ReflectCube     >= 0) R_Mesh_TexBind(GL20TU_REFLECTCUBE       , rsurface.texture->reflectcubetexture ? rsurface.texture->reflectcubetexture : r_texture_whitecube);
5986                 if (r_glsl_permutation->loc_Texture_FogHeightTexture>= 0) R_Mesh_TexBind(GL20TU_FOGHEIGHTTEXTURE  , r_texture_fogheighttexture                          );
5987                 if (r_glsl_permutation->loc_Texture_FogMask         >= 0) R_Mesh_TexBind(GL20TU_FOGMASK           , r_texture_fogattenuation                            );
5988                 if (r_glsl_permutation->loc_Texture_Lightmap        >= 0) R_Mesh_TexBind(GL20TU_LIGHTMAP          , rsurface.lightmaptexture ? rsurface.lightmaptexture : r_texture_white);
5989                 if (r_glsl_permutation->loc_Texture_Deluxemap       >= 0) R_Mesh_TexBind(GL20TU_DELUXEMAP         , rsurface.deluxemaptexture ? rsurface.deluxemaptexture : r_texture_blanknormalmap);
5990                 if (r_glsl_permutation->loc_Texture_Attenuation     >= 0) R_Mesh_TexBind(GL20TU_ATTENUATION       , r_shadow_attenuationgradienttexture                 );
5991                 if (rsurfacepass == RSURFPASS_BACKGROUND)
5992                 {
5993                         if(r_glsl_permutation->loc_Texture_Refraction >= 0) R_Mesh_TexBind(GL20TU_REFRACTION        , waterplane->texture_refraction ? waterplane->texture_refraction : r_texture_black);
5994                         else if(r_glsl_permutation->loc_Texture_First >= 0) R_Mesh_TexBind(GL20TU_FIRST             , waterplane->texture_camera ? waterplane->texture_camera : r_texture_black);
5995                         if(r_glsl_permutation->loc_Texture_Reflection >= 0) R_Mesh_TexBind(GL20TU_REFLECTION        , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);
5996                 }
5997                 else
5998                 {
5999                         if (permutation & SHADERPERMUTATION_REFLECTION        ) R_Mesh_TexBind(GL20TU_REFLECTION        , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);
6000                 }
6001 //              if (r_glsl_permutation->loc_Texture_ScreenDepth     >= 0) R_Mesh_TexBind(GL20TU_SCREENDEPTH       , r_shadow_prepassgeometrydepthtexture                );
6002 //              if (r_glsl_permutation->loc_Texture_ScreenNormalMap >= 0) R_Mesh_TexBind(GL20TU_SCREENNORMALMAP   , r_shadow_prepassgeometrynormalmaptexture            );
6003                 if (r_glsl_permutation->loc_Texture_ScreenDiffuse   >= 0) R_Mesh_TexBind(GL20TU_SCREENDIFFUSE     , r_shadow_prepasslightingdiffusetexture              );
6004                 if (r_glsl_permutation->loc_Texture_ScreenSpecular  >= 0) R_Mesh_TexBind(GL20TU_SCREENSPECULAR    , r_shadow_prepasslightingspeculartexture             );
6005                 if (rsurface.rtlight || (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW)))
6006                 {
6007                         if (r_glsl_permutation->loc_Texture_ShadowMap2D     >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAP2D, r_shadow_shadowmap2dtexture                         );
6008                         if (rsurface.rtlight)
6009                         {
6010                                 if (r_glsl_permutation->loc_Texture_Cube            >= 0) R_Mesh_TexBind(GL20TU_CUBE              , rsurface.rtlight->currentcubemap                    );
6011                                 if (r_glsl_permutation->loc_Texture_CubeProjection  >= 0) R_Mesh_TexBind(GL20TU_CUBEPROJECTION    , r_shadow_shadowmapvsdcttexture                      );
6012                         }
6013                 }
6014                 CHECKGLERROR
6015                 break;
6016         case RENDERPATH_CGGL:
6017 #ifdef SUPPORTCG
6018                 if (gl_mesh_separatearrays.integer)
6019                 {
6020                         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | (rsurface.modellightmapcolor4f ? BATCHNEED_ARRAY_VERTEXCOLOR : 0) | BATCHNEED_ARRAY_TEXCOORD | (rsurface.uselightmaptexture ? BATCHNEED_ARRAY_LIGHTMAP : 0), texturenumsurfaces, texturesurfacelist);
6021                         R_Mesh_VertexPointer(     3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
6022                         R_Mesh_ColorPointer(      4, GL_FLOAT, sizeof(float[4]), rsurface.batchlightmapcolor4f, rsurface.batchlightmapcolor4f_vertexbuffer, rsurface.batchlightmapcolor4f_bufferoffset);
6023                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
6024                         R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchsvector3f, rsurface.batchsvector3f_vertexbuffer, rsurface.batchsvector3f_bufferoffset);
6025                         R_Mesh_TexCoordPointer(2, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchtvector3f, rsurface.batchtvector3f_vertexbuffer, rsurface.batchtvector3f_bufferoffset);
6026                         R_Mesh_TexCoordPointer(3, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchnormal3f, rsurface.batchnormal3f_vertexbuffer, rsurface.batchnormal3f_bufferoffset);
6027                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordlightmap2f_vertexbuffer, rsurface.batchtexcoordlightmap2f_bufferoffset);
6028                 }
6029                 else
6030                 {
6031                         RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | (rsurface.modellightmapcolor4f ? BATCHNEED_VERTEXMESH_VERTEXCOLOR : 0) | BATCHNEED_VERTEXMESH_TEXCOORD | (rsurface.uselightmaptexture ? BATCHNEED_VERTEXMESH_LIGHTMAP : 0), texturenumsurfaces, texturesurfacelist);
6032                         R_Mesh_PrepareVertices_Mesh(rsurface.batchnumvertices, rsurface.batchvertexmesh, rsurface.batchvertexmeshbuffer);
6033                 }
6034                 R_SetupShader_SetPermutationCG(mode, permutation);
6035                 if (r_cg_permutation->fp_ModelToReflectCube) {Matrix4x4_ToArrayFloatGL(&rsurface.matrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->fp_ModelToReflectCube, m16f);}CHECKCGERROR
6036                 if (mode == SHADERMODE_LIGHTSOURCE)
6037                 {
6038                         if (r_cg_permutation->vp_ModelToLight) {Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelToLight, m16f);}CHECKCGERROR
6039                         if (r_cg_permutation->vp_LightPosition) cgGLSetParameter3f(r_cg_permutation->vp_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);CHECKCGERROR
6040                 }
6041                 else
6042                 {
6043                         if (mode == SHADERMODE_LIGHTDIRECTION)
6044                         {
6045                                 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
6046                         }
6047                 }
6048                 if (r_cg_permutation->vp_TexMatrix) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currenttexmatrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_TexMatrix, m16f);}CHECKCGERROR
6049                 if (r_cg_permutation->vp_BackgroundTexMatrix) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currentbackgroundtexmatrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_BackgroundTexMatrix, m16f);}CHECKCGERROR
6050                 if (r_cg_permutation->vp_ShadowMapMatrix) {Matrix4x4_ToArrayFloatGL(&r_shadow_shadowmapmatrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_ShadowMapMatrix, m16f);}CHECKGLERROR
6051                 if (r_cg_permutation->vp_EyePosition) cgGLSetParameter3f(r_cg_permutation->vp_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);CHECKCGERROR
6052                 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
6053                 CHECKGLERROR
6054
6055                 if (mode == SHADERMODE_LIGHTSOURCE)
6056                 {
6057                         if (r_cg_permutation->fp_LightPosition) cgGLSetParameter3f(r_cg_permutation->fp_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);CHECKCGERROR
6058                         if (r_cg_permutation->fp_LightColor) cgGLSetParameter3f(r_cg_permutation->fp_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);CHECKCGERROR
6059                         if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, colormod[0] * ambientscale, colormod[1] * ambientscale, colormod[2] * ambientscale);CHECKCGERROR
6060                         if (r_cg_permutation->fp_Color_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_Color_Diffuse, colormod[0] * diffusescale, colormod[1] * diffusescale, colormod[2] * diffusescale);CHECKCGERROR
6061                         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
6062
6063                         // additive passes are only darkened by fog, not tinted
6064                         if (r_cg_permutation->fp_FogColor) cgGLSetParameter3f(r_cg_permutation->fp_FogColor, 0, 0, 0);CHECKCGERROR
6065                         if (r_cg_permutation->fp_SpecularPower) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f));CHECKCGERROR
6066                 }
6067                 else
6068                 {
6069                         if (mode == SHADERMODE_FLATCOLOR)
6070                         {
6071                                 if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, colormod[0], colormod[1], colormod[2]);CHECKCGERROR
6072                         }
6073                         else if (mode == SHADERMODE_LIGHTDIRECTION)
6074                         {
6075                                 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
6076                                 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
6077                                 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
6078                                 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
6079                                 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
6080                                 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
6081                                 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
6082                         }
6083                         else
6084                         {
6085                                 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
6086                                 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
6087                                 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
6088                                 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
6089                                 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
6090                         }
6091                         // additive passes are only darkened by fog, not tinted
6092                         if (r_cg_permutation->fp_FogColor)
6093                         {
6094                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
6095                                         cgGLSetParameter3f(r_cg_permutation->fp_FogColor, 0, 0, 0);
6096                                 else
6097                                         cgGLSetParameter3f(r_cg_permutation->fp_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
6098                                 CHECKCGERROR
6099                         }
6100                         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
6101                         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
6102                         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
6103                         if (r_cg_permutation->fp_RefractColor) cgGLSetParameter4fv(r_cg_permutation->fp_RefractColor, rsurface.texture->refractcolor4f[0], rsurface.texture->refractcolor4f[1], rsurface.texture->refractcolor4f[2], rsurface.texture->refractcolor4f[3] * rsurface.texture->lightmapcolor[3]);CHECKCGERROR
6104                         if (r_cg_permutation->fp_ReflectColor) cgGLSetParameter4fv(r_cg_permutation->fp_ReflectColor, rsurface.texture->reflectcolor4f[0], rsurface.texture->reflectcolor4f[1], rsurface.texture->reflectcolor4f[2], rsurface.texture->reflectcolor4f[3] * rsurface.texture->lightmapcolor[3]);CHECKCGERROR
6105                         if (r_cg_permutation->fp_ReflectFactor) cgGLSetParameter1f(r_cg_permutation->fp_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);CHECKCGERROR
6106                         if (r_cg_permutation->fp_ReflectOffset) cgGLSetParameter1f(r_cg_permutation->fp_ReflectOffset, rsurface.texture->reflectmin);CHECKCGERROR
6107                         if (r_cg_permutation->fp_SpecularPower) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f));CHECKCGERROR
6108                         if (r_cg_permutation->fp_NormalmapScrollBlend) cgGLSetParameter2f(r_cg_permutation->fp_NormalmapScrollBlend, rsurface.texture->r_water_waterscroll[0], rsurface.texture->r_water_waterscroll[1]);
6109                 }
6110                 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
6111                 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
6112                 if (r_cg_permutation->fp_Color_Glow) cgGLSetParameter3f(r_cg_permutation->fp_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]);CHECKCGERROR
6113                 if (r_cg_permutation->fp_Alpha) cgGLSetParameter1f(r_cg_permutation->fp_Alpha, rsurface.texture->lightmapcolor[3] * ((rsurface.texture->basematerialflags & MATERIALFLAG_WATERSHADER && r_waterstate.enabled && !r_refdef.view.isoverlay) ? rsurface.texture->r_water_wateralpha : 1));CHECKCGERROR
6114                 if (r_cg_permutation->fp_EyePosition) cgGLSetParameter3f(r_cg_permutation->fp_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);CHECKCGERROR
6115                 if (r_cg_permutation->fp_Color_Pants)
6116                 {
6117                         if (rsurface.texture->pantstexture)
6118                                 cgGLSetParameter3f(r_cg_permutation->fp_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
6119                         else
6120                                 cgGLSetParameter3f(r_cg_permutation->fp_Color_Pants, 0, 0, 0);
6121                         CHECKCGERROR
6122                 }
6123                 if (r_cg_permutation->fp_Color_Shirt)
6124                 {
6125                         if (rsurface.texture->shirttexture)
6126                                 cgGLSetParameter3f(r_cg_permutation->fp_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
6127                         else
6128                                 cgGLSetParameter3f(r_cg_permutation->fp_Color_Shirt, 0, 0, 0);
6129                         CHECKCGERROR
6130                 }
6131                 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
6132                 if (r_cg_permutation->fp_FogPlaneViewDist) cgGLSetParameter1f(r_cg_permutation->fp_FogPlaneViewDist, rsurface.fogplaneviewdist);CHECKCGERROR
6133                 if (r_cg_permutation->fp_FogRangeRecip) cgGLSetParameter1f(r_cg_permutation->fp_FogRangeRecip, rsurface.fograngerecip);CHECKCGERROR
6134                 if (r_cg_permutation->fp_FogHeightFade) cgGLSetParameter1f(r_cg_permutation->fp_FogHeightFade, rsurface.fogheightfade);CHECKCGERROR
6135                 if (r_cg_permutation->fp_OffsetMapping_Scale) cgGLSetParameter1f(r_cg_permutation->fp_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);CHECKCGERROR
6136                 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
6137                 if (r_cg_permutation->fp_PixelToScreenTexCoord) cgGLSetParameter2f(r_cg_permutation->fp_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);CHECKCGERROR
6138
6139         //      if (r_cg_permutation->fp_Texture_First          ) CG_BindTexture(r_cg_permutation->fp_Texture_First          , r_texture_white                                     );CHECKCGERROR
6140         //      if (r_cg_permutation->fp_Texture_Second         ) CG_BindTexture(r_cg_permutation->fp_Texture_Second         , r_texture_white                                     );CHECKCGERROR
6141         //      if (r_cg_permutation->fp_Texture_GammaRamps     ) CG_BindTexture(r_cg_permutation->fp_Texture_GammaRamps     , r_texture_gammaramps                                );CHECKCGERROR
6142                 if (r_cg_permutation->fp_Texture_Normal         ) CG_BindTexture(r_cg_permutation->fp_Texture_Normal         , rsurface.texture->nmaptexture                       );CHECKCGERROR
6143                 if (r_cg_permutation->fp_Texture_Color          ) CG_BindTexture(r_cg_permutation->fp_Texture_Color          , rsurface.texture->basetexture                       );CHECKCGERROR
6144                 if (r_cg_permutation->fp_Texture_Gloss          ) CG_BindTexture(r_cg_permutation->fp_Texture_Gloss          , rsurface.texture->glosstexture                      );CHECKCGERROR
6145                 if (r_cg_permutation->fp_Texture_Glow           ) CG_BindTexture(r_cg_permutation->fp_Texture_Glow           , rsurface.texture->glowtexture                       );CHECKCGERROR
6146                 if (r_cg_permutation->fp_Texture_SecondaryNormal) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryNormal, rsurface.texture->backgroundnmaptexture             );CHECKCGERROR
6147                 if (r_cg_permutation->fp_Texture_SecondaryColor ) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryColor , rsurface.texture->backgroundbasetexture             );CHECKCGERROR
6148                 if (r_cg_permutation->fp_Texture_SecondaryGloss ) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryGloss , rsurface.texture->backgroundglosstexture            );CHECKCGERROR
6149                 if (r_cg_permutation->fp_Texture_SecondaryGlow  ) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryGlow  , rsurface.texture->backgroundglowtexture             );CHECKCGERROR
6150                 if (r_cg_permutation->fp_Texture_Pants          ) CG_BindTexture(r_cg_permutation->fp_Texture_Pants          , rsurface.texture->pantstexture                      );CHECKCGERROR
6151                 if (r_cg_permutation->fp_Texture_Shirt          ) CG_BindTexture(r_cg_permutation->fp_Texture_Shirt          , rsurface.texture->shirttexture                      );CHECKCGERROR
6152                 if (r_cg_permutation->fp_Texture_ReflectMask    ) CG_BindTexture(r_cg_permutation->fp_Texture_ReflectMask    , rsurface.texture->reflectmasktexture                );CHECKCGERROR
6153                 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
6154                 if (r_cg_permutation->fp_Texture_FogHeightTexture) CG_BindTexture(r_cg_permutation->fp_Texture_FogHeightTexture, r_texture_fogheighttexture                         );CHECKCGERROR
6155                 if (r_cg_permutation->fp_Texture_FogMask        ) CG_BindTexture(r_cg_permutation->fp_Texture_FogMask        , r_texture_fogattenuation                            );CHECKCGERROR
6156                 if (r_cg_permutation->fp_Texture_Lightmap       ) CG_BindTexture(r_cg_permutation->fp_Texture_Lightmap       , rsurface.lightmaptexture ? rsurface.lightmaptexture : r_texture_white);CHECKCGERROR
6157                 if (r_cg_permutation->fp_Texture_Deluxemap      ) CG_BindTexture(r_cg_permutation->fp_Texture_Deluxemap      , rsurface.deluxemaptexture ? rsurface.deluxemaptexture : r_texture_blanknormalmap);CHECKCGERROR
6158                 if (r_cg_permutation->fp_Texture_Attenuation    ) CG_BindTexture(r_cg_permutation->fp_Texture_Attenuation    , r_shadow_attenuationgradienttexture                 );CHECKCGERROR
6159                 if (rsurfacepass == RSURFPASS_BACKGROUND)
6160                 {
6161                         if (r_cg_permutation->fp_Texture_Refraction     ) CG_BindTexture(r_cg_permutation->fp_Texture_Refraction     , waterplane->texture_refraction ? waterplane->texture_refraction : r_texture_black);CHECKCGERROR
6162                         else if (r_cg_permutation->fp_Texture_First     ) CG_BindTexture(r_cg_permutation->fp_Texture_First          , waterplane->texture_camera ? waterplane->texture_camera : r_texture_black);CHECKCGERROR
6163                         if (r_cg_permutation->fp_Texture_Reflection     ) CG_BindTexture(r_cg_permutation->fp_Texture_Reflection     , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);CHECKCGERROR
6164                 }
6165                 else
6166                 {
6167                         if (r_cg_permutation->fp_Texture_Reflection     ) CG_BindTexture(r_cg_permutation->fp_Texture_Reflection     , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);CHECKCGERROR
6168                 }
6169                 if (r_cg_permutation->fp_Texture_ScreenDepth    ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDepth    , r_shadow_prepassgeometrydepthtexture                );CHECKCGERROR
6170                 if (r_cg_permutation->fp_Texture_ScreenNormalMap) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenNormalMap, r_shadow_prepassgeometrynormalmaptexture            );CHECKCGERROR
6171                 if (r_cg_permutation->fp_Texture_ScreenDiffuse  ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDiffuse  , r_shadow_prepasslightingdiffusetexture              );CHECKCGERROR
6172                 if (r_cg_permutation->fp_Texture_ScreenSpecular ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenSpecular , r_shadow_prepasslightingspeculartexture             );CHECKCGERROR
6173                 if (rsurface.rtlight || (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW)))
6174                 {
6175                         if (r_cg_permutation->fp_Texture_ShadowMap2D    ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMap2D    , r_shadow_shadowmap2dtexture                         );CHECKCGERROR
6176                         if (rsurface.rtlight)
6177                         {
6178                                 if (r_cg_permutation->fp_Texture_Cube           ) CG_BindTexture(r_cg_permutation->fp_Texture_Cube           , rsurface.rtlight->currentcubemap                    );CHECKCGERROR
6179                                 if (r_cg_permutation->fp_Texture_CubeProjection ) CG_BindTexture(r_cg_permutation->fp_Texture_CubeProjection , r_shadow_shadowmapvsdcttexture                      );CHECKCGERROR
6180                         }
6181                 }
6182
6183                 CHECKGLERROR
6184 #endif
6185                 break;
6186         case RENDERPATH_GL13:
6187         case RENDERPATH_GL11:
6188                 break;
6189         }
6190 }
6191
6192 void R_SetupShader_DeferredLight(const rtlight_t *rtlight)
6193 {
6194         // select a permutation of the lighting shader appropriate to this
6195         // combination of texture, entity, light source, and fogging, only use the
6196         // minimum features necessary to avoid wasting rendering time in the
6197         // fragment shader on features that are not being used
6198         unsigned int permutation = 0;
6199         unsigned int mode = 0;
6200         const float *lightcolorbase = rtlight->currentcolor;
6201         float ambientscale = rtlight->ambientscale;
6202         float diffusescale = rtlight->diffusescale;
6203         float specularscale = rtlight->specularscale;
6204         // this is the location of the light in view space
6205         vec3_t viewlightorigin;
6206         // this transforms from view space (camera) to light space (cubemap)
6207         matrix4x4_t viewtolight;
6208         matrix4x4_t lighttoview;
6209         float viewtolight16f[16];
6210         float range = 1.0f / r_shadow_deferred_8bitrange.value;
6211         // light source
6212         mode = SHADERMODE_DEFERREDLIGHTSOURCE;
6213         if (rtlight->currentcubemap != r_texture_whitecube)
6214                 permutation |= SHADERPERMUTATION_CUBEFILTER;
6215         if (diffusescale > 0)
6216                 permutation |= SHADERPERMUTATION_DIFFUSE;
6217         if (specularscale > 0)
6218                 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
6219         if (r_shadow_usingshadowmap2d)
6220         {
6221                 permutation |= SHADERPERMUTATION_SHADOWMAP2D;
6222                 if (r_shadow_shadowmapvsdct)
6223                         permutation |= SHADERPERMUTATION_SHADOWMAPVSDCT;
6224
6225                 if (r_shadow_shadowmapsampler)
6226                         permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
6227                 if (r_shadow_shadowmappcf > 1)
6228                         permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
6229                 else if (r_shadow_shadowmappcf)
6230                         permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
6231         }
6232         Matrix4x4_Transform(&r_refdef.view.viewport.viewmatrix, rtlight->shadoworigin, viewlightorigin);
6233         Matrix4x4_Concat(&lighttoview, &r_refdef.view.viewport.viewmatrix, &rtlight->matrix_lighttoworld);
6234         Matrix4x4_Invert_Simple(&viewtolight, &lighttoview);
6235         Matrix4x4_ToArrayFloatGL(&viewtolight, viewtolight16f);
6236         switch(vid.renderpath)
6237         {
6238         case RENDERPATH_D3D9:
6239 #ifdef SUPPORTD3D
6240                 R_SetupShader_SetPermutationHLSL(mode, permutation);
6241                 hlslPSSetParameter3f(D3DPSREGISTER_LightPosition, viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]);
6242                 hlslPSSetParameter16f(D3DPSREGISTER_ViewToLight, viewtolight16f);
6243                 hlslPSSetParameter3f(D3DPSREGISTER_DeferredColor_Ambient , lightcolorbase[0] * ambientscale  * range, lightcolorbase[1] * ambientscale  * range, lightcolorbase[2] * ambientscale  * range);
6244                 hlslPSSetParameter3f(D3DPSREGISTER_DeferredColor_Diffuse , lightcolorbase[0] * diffusescale  * range, lightcolorbase[1] * diffusescale  * range, lightcolorbase[2] * diffusescale  * range);
6245                 hlslPSSetParameter3f(D3DPSREGISTER_DeferredColor_Specular, lightcolorbase[0] * specularscale * range, lightcolorbase[1] * specularscale * range, lightcolorbase[2] * specularscale * range);
6246                 hlslPSSetParameter2f(D3DPSREGISTER_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);
6247                 hlslPSSetParameter4f(D3DPSREGISTER_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);
6248                 hlslPSSetParameter1f(D3DPSREGISTER_SpecularPower, (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * (r_shadow_glossexact.integer ? 0.25f : 1.0f));
6249                 hlslPSSetParameter2f(D3DPSREGISTER_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);
6250                 hlslPSSetParameter2f(D3DPSREGISTER_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);
6251
6252                 R_Mesh_TexBind(GL20TU_ATTENUATION        , r_shadow_attenuationgradienttexture                 );
6253                 R_Mesh_TexBind(GL20TU_SCREENDEPTH        , r_shadow_prepassgeometrydepthcolortexture           );
6254                 R_Mesh_TexBind(GL20TU_SCREENNORMALMAP    , r_shadow_prepassgeometrynormalmaptexture            );
6255                 R_Mesh_TexBind(GL20TU_CUBE               , rsurface.rtlight->currentcubemap                    );
6256                 R_Mesh_TexBind(GL20TU_SHADOWMAP2D        , r_shadow_shadowmap2dcolortexture                    );
6257                 R_Mesh_TexBind(GL20TU_CUBEPROJECTION     , r_shadow_shadowmapvsdcttexture                      );
6258 #endif
6259                 break;
6260         case RENDERPATH_D3D10:
6261                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
6262                 break;
6263         case RENDERPATH_D3D11:
6264                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
6265                 break;
6266         case RENDERPATH_GL20:
6267                 R_SetupShader_SetPermutationGLSL(mode, permutation);
6268                 if (r_glsl_permutation->loc_LightPosition             >= 0) qglUniform3fARB(       r_glsl_permutation->loc_LightPosition            , viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]);
6269                 if (r_glsl_permutation->loc_ViewToLight               >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ViewToLight              , 1, false, viewtolight16f);
6270                 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);
6271                 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);
6272                 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);
6273                 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]);
6274                 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]);
6275                 if (r_glsl_permutation->loc_SpecularPower             >= 0) qglUniform1fARB(       r_glsl_permutation->loc_SpecularPower            , (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * (r_shadow_glossexact.integer ? 0.25f : 1.0f));
6276                 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]);
6277                 if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
6278
6279                 if (r_glsl_permutation->loc_Texture_Attenuation       >= 0) R_Mesh_TexBind(GL20TU_ATTENUATION        , r_shadow_attenuationgradienttexture                 );
6280                 if (r_glsl_permutation->loc_Texture_ScreenDepth       >= 0) R_Mesh_TexBind(GL20TU_SCREENDEPTH        , r_shadow_prepassgeometrydepthtexture                );
6281                 if (r_glsl_permutation->loc_Texture_ScreenNormalMap   >= 0) R_Mesh_TexBind(GL20TU_SCREENNORMALMAP    , r_shadow_prepassgeometrynormalmaptexture            );
6282                 if (r_glsl_permutation->loc_Texture_Cube              >= 0) R_Mesh_TexBind(GL20TU_CUBE               , rsurface.rtlight->currentcubemap                    );
6283                 if (r_glsl_permutation->loc_Texture_ShadowMap2D       >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAP2D        , r_shadow_shadowmap2dtexture                         );
6284                 if (r_glsl_permutation->loc_Texture_CubeProjection    >= 0) R_Mesh_TexBind(GL20TU_CUBEPROJECTION     , r_shadow_shadowmapvsdcttexture                      );
6285                 break;
6286         case RENDERPATH_CGGL:
6287 #ifdef SUPPORTCG
6288                 R_SetupShader_SetPermutationCG(mode, permutation);
6289                 if (r_cg_permutation->fp_LightPosition            ) cgGLSetParameter3f(r_cg_permutation->fp_LightPosition, viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]);CHECKCGERROR
6290                 if (r_cg_permutation->fp_ViewToLight              ) cgGLSetMatrixParameterfc(r_cg_permutation->fp_ViewToLight, viewtolight16f);CHECKCGERROR
6291                 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
6292                 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
6293                 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
6294                 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
6295                 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
6296                 if (r_cg_permutation->fp_SpecularPower            ) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * (r_shadow_glossexact.integer ? 0.25f : 1.0f));CHECKCGERROR
6297                 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
6298                 if (r_cg_permutation->fp_PixelToScreenTexCoord    ) cgGLSetParameter2f(r_cg_permutation->fp_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);CHECKCGERROR
6299
6300                 if (r_cg_permutation->fp_Texture_Attenuation      ) CG_BindTexture(r_cg_permutation->fp_Texture_Attenuation    , r_shadow_attenuationgradienttexture                 );CHECKCGERROR
6301                 if (r_cg_permutation->fp_Texture_ScreenDepth      ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDepth    , r_shadow_prepassgeometrydepthtexture                );CHECKCGERROR
6302                 if (r_cg_permutation->fp_Texture_ScreenNormalMap  ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenNormalMap, r_shadow_prepassgeometrynormalmaptexture            );CHECKCGERROR
6303                 if (r_cg_permutation->fp_Texture_Cube             ) CG_BindTexture(r_cg_permutation->fp_Texture_Cube           , rsurface.rtlight->currentcubemap                    );CHECKCGERROR
6304                 if (r_cg_permutation->fp_Texture_ShadowMap2D      ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMap2D    , r_shadow_shadowmap2dtexture                         );CHECKCGERROR
6305                 if (r_cg_permutation->fp_Texture_CubeProjection   ) CG_BindTexture(r_cg_permutation->fp_Texture_CubeProjection , r_shadow_shadowmapvsdcttexture                      );CHECKCGERROR
6306 #endif
6307                 break;
6308         case RENDERPATH_GL13:
6309         case RENDERPATH_GL11:
6310                 break;
6311         }
6312 }
6313
6314 #define SKINFRAME_HASH 1024
6315
6316 typedef struct
6317 {
6318         int loadsequence; // incremented each level change
6319         memexpandablearray_t array;
6320         skinframe_t *hash[SKINFRAME_HASH];
6321 }
6322 r_skinframe_t;
6323 r_skinframe_t r_skinframe;
6324
6325 void R_SkinFrame_PrepareForPurge(void)
6326 {
6327         r_skinframe.loadsequence++;
6328         // wrap it without hitting zero
6329         if (r_skinframe.loadsequence >= 200)
6330                 r_skinframe.loadsequence = 1;
6331 }
6332
6333 void R_SkinFrame_MarkUsed(skinframe_t *skinframe)
6334 {
6335         if (!skinframe)
6336                 return;
6337         // mark the skinframe as used for the purging code
6338         skinframe->loadsequence = r_skinframe.loadsequence;
6339 }
6340
6341 void R_SkinFrame_Purge(void)
6342 {
6343         int i;
6344         skinframe_t *s;
6345         for (i = 0;i < SKINFRAME_HASH;i++)
6346         {
6347                 for (s = r_skinframe.hash[i];s;s = s->next)
6348                 {
6349                         if (s->loadsequence && s->loadsequence != r_skinframe.loadsequence)
6350                         {
6351                                 if (s->merged == s->base)
6352                                         s->merged = NULL;
6353                                 // FIXME: maybe pass a pointer to the pointer to R_PurgeTexture and reset it to NULL inside? [11/29/2007 Black]
6354                                 R_PurgeTexture(s->stain );s->stain  = NULL;
6355                                 R_PurgeTexture(s->merged);s->merged = NULL;
6356                                 R_PurgeTexture(s->base  );s->base   = NULL;
6357                                 R_PurgeTexture(s->pants );s->pants  = NULL;
6358                                 R_PurgeTexture(s->shirt );s->shirt  = NULL;
6359                                 R_PurgeTexture(s->nmap  );s->nmap   = NULL;
6360                                 R_PurgeTexture(s->gloss );s->gloss  = NULL;
6361                                 R_PurgeTexture(s->glow  );s->glow   = NULL;
6362                                 R_PurgeTexture(s->fog   );s->fog    = NULL;
6363                                 R_PurgeTexture(s->reflect);s->reflect = NULL;
6364                                 s->loadsequence = 0;
6365                         }
6366                 }
6367         }
6368 }
6369
6370 skinframe_t *R_SkinFrame_FindNextByName( skinframe_t *last, const char *name ) {
6371         skinframe_t *item;
6372         char basename[MAX_QPATH];
6373
6374         Image_StripImageExtension(name, basename, sizeof(basename));
6375
6376         if( last == NULL ) {
6377                 int hashindex;
6378                 hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
6379                 item = r_skinframe.hash[hashindex];
6380         } else {
6381                 item = last->next;
6382         }
6383
6384         // linearly search through the hash bucket
6385         for( ; item ; item = item->next ) {
6386                 if( !strcmp( item->basename, basename ) ) {
6387                         return item;
6388                 }
6389         }
6390         return NULL;
6391 }
6392
6393 skinframe_t *R_SkinFrame_Find(const char *name, int textureflags, int comparewidth, int compareheight, int comparecrc, qboolean add)
6394 {
6395         skinframe_t *item;
6396         int hashindex;
6397         char basename[MAX_QPATH];
6398
6399         Image_StripImageExtension(name, basename, sizeof(basename));
6400
6401         hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
6402         for (item = r_skinframe.hash[hashindex];item;item = item->next)
6403                 if (!strcmp(item->basename, basename) && item->textureflags == textureflags && item->comparewidth == comparewidth && item->compareheight == compareheight && item->comparecrc == comparecrc)
6404                         break;
6405
6406         if (!item) {
6407                 rtexture_t *dyntexture;
6408                 // check whether its a dynamic texture
6409                 dyntexture = CL_GetDynTexture( basename );
6410                 if (!add && !dyntexture)
6411                         return NULL;
6412                 item = (skinframe_t *)Mem_ExpandableArray_AllocRecord(&r_skinframe.array);
6413                 memset(item, 0, sizeof(*item));
6414                 strlcpy(item->basename, basename, sizeof(item->basename));
6415                 item->base = dyntexture; // either NULL or dyntexture handle
6416                 item->textureflags = textureflags;
6417                 item->comparewidth = comparewidth;
6418                 item->compareheight = compareheight;
6419                 item->comparecrc = comparecrc;
6420                 item->next = r_skinframe.hash[hashindex];
6421                 r_skinframe.hash[hashindex] = item;
6422         }
6423         else if( item->base == NULL )
6424         {
6425                 rtexture_t *dyntexture;
6426                 // check whether its a dynamic texture
6427                 // 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]
6428                 dyntexture = CL_GetDynTexture( basename );
6429                 item->base = dyntexture; // either NULL or dyntexture handle
6430         }
6431
6432         R_SkinFrame_MarkUsed(item);
6433         return item;
6434 }
6435
6436 #define R_SKINFRAME_LOAD_AVERAGE_COLORS(cnt, getpixel) \
6437         { \
6438                 unsigned long long avgcolor[5], wsum; \
6439                 int pix, comp, w; \
6440                 avgcolor[0] = 0; \
6441                 avgcolor[1] = 0; \
6442                 avgcolor[2] = 0; \
6443                 avgcolor[3] = 0; \
6444                 avgcolor[4] = 0; \
6445                 wsum = 0; \
6446                 for(pix = 0; pix < cnt; ++pix) \
6447                 { \
6448                         w = 0; \
6449                         for(comp = 0; comp < 3; ++comp) \
6450                                 w += getpixel; \
6451                         if(w) /* ignore perfectly black pixels because that is better for model skins */ \
6452                         { \
6453                                 ++wsum; \
6454                                 /* comp = 3; -- not needed, comp is always 3 when we get here */ \
6455                                 w = getpixel; \
6456                                 for(comp = 0; comp < 3; ++comp) \
6457                                         avgcolor[comp] += getpixel * w; \
6458                                 avgcolor[3] += w; \
6459                         } \
6460                         /* comp = 3; -- not needed, comp is always 3 when we get here */ \
6461                         avgcolor[4] += getpixel; \
6462                 } \
6463                 if(avgcolor[3] == 0) /* no pixels seen? even worse */ \
6464                         avgcolor[3] = 1; \
6465                 skinframe->avgcolor[0] = avgcolor[2] / (255.0 * avgcolor[3]); \
6466                 skinframe->avgcolor[1] = avgcolor[1] / (255.0 * avgcolor[3]); \
6467                 skinframe->avgcolor[2] = avgcolor[0] / (255.0 * avgcolor[3]); \
6468                 skinframe->avgcolor[3] = avgcolor[4] / (255.0 * cnt); \
6469         }
6470
6471 extern cvar_t gl_picmip;
6472 skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboolean complain)
6473 {
6474         int j;
6475         unsigned char *pixels;
6476         unsigned char *bumppixels;
6477         unsigned char *basepixels = NULL;
6478         int basepixels_width = 0;
6479         int basepixels_height = 0;
6480         skinframe_t *skinframe;
6481         rtexture_t *ddsbase = NULL;
6482         qboolean ddshasalpha = false;
6483         float ddsavgcolor[4];
6484         char basename[MAX_QPATH];
6485         int miplevel = R_PicmipForFlags(textureflags);
6486         int savemiplevel = miplevel;
6487         int mymiplevel;
6488
6489         if (cls.state == ca_dedicated)
6490                 return NULL;
6491
6492         // return an existing skinframe if already loaded
6493         // if loading of the first image fails, don't make a new skinframe as it
6494         // would cause all future lookups of this to be missing
6495         skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
6496         if (skinframe && skinframe->base)
6497                 return skinframe;
6498
6499         Image_StripImageExtension(name, basename, sizeof(basename));
6500
6501         // check for DDS texture file first
6502         if (!r_loaddds || !(ddsbase = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s.dds", basename), textureflags, &ddshasalpha, ddsavgcolor, miplevel)))
6503         {
6504                 basepixels = loadimagepixelsbgra(name, complain, true, r_texture_convertsRGB_skin.integer != 0, &miplevel);
6505                 if (basepixels == NULL)
6506                         return NULL;
6507         }
6508
6509         // FIXME handle miplevel
6510
6511         if (developer_loading.integer)
6512                 Con_Printf("loading skin \"%s\"\n", name);
6513
6514         // we've got some pixels to store, so really allocate this new texture now
6515         if (!skinframe)
6516                 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, true);
6517         skinframe->stain = NULL;
6518         skinframe->merged = NULL;
6519         skinframe->base = NULL;
6520         skinframe->pants = NULL;
6521         skinframe->shirt = NULL;
6522         skinframe->nmap = NULL;
6523         skinframe->gloss = NULL;
6524         skinframe->glow = NULL;
6525         skinframe->fog = NULL;
6526         skinframe->reflect = NULL;
6527         skinframe->hasalpha = false;
6528
6529         if (ddsbase)
6530         {
6531                 skinframe->base = ddsbase;
6532                 skinframe->hasalpha = ddshasalpha;
6533                 VectorCopy(ddsavgcolor, skinframe->avgcolor);
6534                 if (r_loadfog && skinframe->hasalpha)
6535                         skinframe->fog = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_mask.dds", skinframe->basename), textureflags | TEXF_ALPHA, NULL, NULL, miplevel);
6536                 //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]);
6537         }
6538         else
6539         {
6540                 basepixels_width = image_width;
6541                 basepixels_height = image_height;
6542                 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);
6543                 if (textureflags & TEXF_ALPHA)
6544                 {
6545                         for (j = 3;j < basepixels_width * basepixels_height * 4;j += 4)
6546                         {
6547                                 if (basepixels[j] < 255)
6548                                 {
6549                                         skinframe->hasalpha = true;
6550                                         break;
6551                                 }
6552                         }
6553                         if (r_loadfog && skinframe->hasalpha)
6554                         {
6555                                 // has transparent pixels
6556                                 pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
6557                                 for (j = 0;j < image_width * image_height * 4;j += 4)
6558                                 {
6559                                         pixels[j+0] = 255;
6560                                         pixels[j+1] = 255;
6561                                         pixels[j+2] = 255;
6562                                         pixels[j+3] = basepixels[j+3];
6563                                 }
6564                                 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);
6565                                 Mem_Free(pixels);
6566                         }
6567                 }
6568                 R_SKINFRAME_LOAD_AVERAGE_COLORS(basepixels_width * basepixels_height, basepixels[4 * pix + comp]);
6569                 //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]);
6570                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->base)
6571                         R_SaveTextureDDSFile(skinframe->base, va("dds/%s.dds", skinframe->basename), true, skinframe->hasalpha);
6572                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->fog)
6573                         R_SaveTextureDDSFile(skinframe->fog, va("dds/%s_mask.dds", skinframe->basename), true, true);
6574         }
6575
6576         if (r_loaddds)
6577         {
6578                 mymiplevel = savemiplevel;
6579                 if (r_loadnormalmap)
6580                         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);
6581                 skinframe->glow = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_glow.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel);
6582                 if (r_loadgloss)
6583                         skinframe->gloss = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_gloss.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel);
6584                 skinframe->pants = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_pants.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel);
6585                 skinframe->shirt = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_shirt.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel);
6586                 skinframe->reflect = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_reflect.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel);
6587         }
6588
6589         // _norm is the name used by tenebrae and has been adopted as standard
6590         if (r_loadnormalmap && skinframe->nmap == NULL)
6591         {
6592                 mymiplevel = savemiplevel;
6593                 if ((pixels = loadimagepixelsbgra(va("%s_norm", skinframe->basename), false, false, false, &mymiplevel)) != NULL)
6594                 {
6595                         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);
6596                         Mem_Free(pixels);
6597                         pixels = NULL;
6598                 }
6599                 else if (r_shadow_bumpscale_bumpmap.value > 0 && (bumppixels = loadimagepixelsbgra(va("%s_bump", skinframe->basename), false, false, false, &mymiplevel)) != NULL)
6600                 {
6601                         pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
6602                         Image_HeightmapToNormalmap_BGRA(bumppixels, pixels, image_width, image_height, false, r_shadow_bumpscale_bumpmap.value);
6603                         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);
6604                         Mem_Free(pixels);
6605                         Mem_Free(bumppixels);
6606                 }
6607                 else if (r_shadow_bumpscale_basetexture.value > 0)
6608                 {
6609                         pixels = (unsigned char *)Mem_Alloc(tempmempool, basepixels_width * basepixels_height * 4);
6610                         Image_HeightmapToNormalmap_BGRA(basepixels, pixels, basepixels_width, basepixels_height, false, r_shadow_bumpscale_basetexture.value);
6611                         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);
6612                         Mem_Free(pixels);
6613                 }
6614                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->nmap)
6615                         R_SaveTextureDDSFile(skinframe->nmap, va("dds/%s_norm.dds", skinframe->basename), true, true);
6616         }
6617
6618         // _luma is supported only for tenebrae compatibility
6619         // _glow is the preferred name
6620         mymiplevel = savemiplevel;
6621         if (skinframe->glow == NULL && ((pixels = loadimagepixelsbgra(va("%s_glow",  skinframe->basename), false, false, r_texture_convertsRGB_skin.integer != 0, &mymiplevel)) || (pixels = loadimagepixelsbgra(va("%s_luma", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer != 0, &mymiplevel))))
6622         {
6623                 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);
6624                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->glow)
6625                         R_SaveTextureDDSFile(skinframe->glow, va("dds/%s_glow.dds", skinframe->basename), true, true);
6626                 Mem_Free(pixels);pixels = NULL;
6627         }
6628
6629         mymiplevel = savemiplevel;
6630         if (skinframe->gloss == NULL && r_loadgloss && (pixels = loadimagepixelsbgra(va("%s_gloss", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer != 0, &mymiplevel)))
6631         {
6632                 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);
6633                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->gloss)
6634                         R_SaveTextureDDSFile(skinframe->gloss, va("dds/%s_gloss.dds", skinframe->basename), true, true);
6635                 Mem_Free(pixels);
6636                 pixels = NULL;
6637         }
6638
6639         mymiplevel = savemiplevel;
6640         if (skinframe->pants == NULL && (pixels = loadimagepixelsbgra(va("%s_pants", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer != 0, &mymiplevel)))
6641         {
6642                 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);
6643                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->pants)
6644                         R_SaveTextureDDSFile(skinframe->pants, va("dds/%s_pants.dds", skinframe->basename), true, false);
6645                 Mem_Free(pixels);
6646                 pixels = NULL;
6647         }
6648
6649         mymiplevel = savemiplevel;
6650         if (skinframe->shirt == NULL && (pixels = loadimagepixelsbgra(va("%s_shirt", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer != 0, &mymiplevel)))
6651         {
6652                 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);
6653                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->shirt)
6654                         R_SaveTextureDDSFile(skinframe->shirt, va("dds/%s_shirt.dds", skinframe->basename), true, false);
6655                 Mem_Free(pixels);
6656                 pixels = NULL;
6657         }
6658
6659         mymiplevel = savemiplevel;
6660         if (skinframe->reflect == NULL && (pixels = loadimagepixelsbgra(va("%s_reflect", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer != 0, &mymiplevel)))
6661         {
6662                 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);
6663                 if (r_savedds && qglGetCompressedTexImageARB && skinframe->reflect)
6664                         R_SaveTextureDDSFile(skinframe->reflect, va("dds/%s_reflect.dds", skinframe->basename), true, true);
6665                 Mem_Free(pixels);
6666                 pixels = NULL;
6667         }
6668
6669         if (basepixels)
6670                 Mem_Free(basepixels);
6671
6672         return skinframe;
6673 }
6674
6675 // this is only used by .spr32 sprites, HL .spr files, HL .bsp files
6676 skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, const unsigned char *skindata, int width, int height)
6677 {
6678         int i;
6679         unsigned char *temp1, *temp2;
6680         skinframe_t *skinframe;
6681
6682         if (cls.state == ca_dedicated)
6683                 return NULL;
6684
6685         // if already loaded just return it, otherwise make a new skinframe
6686         skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height*4) : 0, true);
6687         if (skinframe && skinframe->base)
6688                 return skinframe;
6689
6690         skinframe->stain = NULL;
6691         skinframe->merged = NULL;
6692         skinframe->base = NULL;
6693         skinframe->pants = NULL;
6694         skinframe->shirt = NULL;
6695         skinframe->nmap = NULL;
6696         skinframe->gloss = NULL;
6697         skinframe->glow = NULL;
6698         skinframe->fog = NULL;
6699         skinframe->reflect = NULL;
6700         skinframe->hasalpha = false;
6701
6702         // if no data was provided, then clearly the caller wanted to get a blank skinframe
6703         if (!skindata)
6704                 return NULL;
6705
6706         if (developer_loading.integer)
6707                 Con_Printf("loading 32bit skin \"%s\"\n", name);
6708
6709         if (r_loadnormalmap && r_shadow_bumpscale_basetexture.value > 0)
6710         {
6711                 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
6712                 temp2 = temp1 + width * height * 4;
6713                 Image_HeightmapToNormalmap_BGRA(skindata, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
6714                 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);
6715                 Mem_Free(temp1);
6716         }
6717         skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_BGRA, textureflags, -1, NULL);
6718         if (textureflags & TEXF_ALPHA)
6719         {
6720                 for (i = 3;i < width * height * 4;i += 4)
6721                 {
6722                         if (skindata[i] < 255)
6723                         {
6724                                 skinframe->hasalpha = true;
6725                                 break;
6726                         }
6727                 }
6728                 if (r_loadfog && skinframe->hasalpha)
6729                 {
6730                         unsigned char *fogpixels = (unsigned char *)Mem_Alloc(tempmempool, width * height * 4);
6731                         memcpy(fogpixels, skindata, width * height * 4);
6732                         for (i = 0;i < width * height * 4;i += 4)
6733                                 fogpixels[i] = fogpixels[i+1] = fogpixels[i+2] = 255;
6734                         skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, fogpixels, TEXTYPE_BGRA, textureflags, -1, NULL);
6735                         Mem_Free(fogpixels);
6736                 }
6737         }
6738
6739         R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, skindata[4 * pix + comp]);
6740         //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]);
6741
6742         return skinframe;
6743 }
6744
6745 skinframe_t *R_SkinFrame_LoadInternalQuake(const char *name, int textureflags, int loadpantsandshirt, int loadglowtexture, const unsigned char *skindata, int width, int height)
6746 {
6747         int i;
6748         int featuresmask;
6749         skinframe_t *skinframe;
6750
6751         if (cls.state == ca_dedicated)
6752                 return NULL;
6753
6754         // if already loaded just return it, otherwise make a new skinframe
6755         skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height) : 0, true);
6756         if (skinframe && skinframe->base)
6757                 return skinframe;
6758
6759         skinframe->stain = NULL;
6760         skinframe->merged = NULL;
6761         skinframe->base = NULL;
6762         skinframe->pants = NULL;
6763         skinframe->shirt = NULL;
6764         skinframe->nmap = NULL;
6765         skinframe->gloss = NULL;
6766         skinframe->glow = NULL;
6767         skinframe->fog = NULL;
6768         skinframe->reflect = NULL;
6769         skinframe->hasalpha = false;
6770
6771         // if no data was provided, then clearly the caller wanted to get a blank skinframe
6772         if (!skindata)
6773                 return NULL;
6774
6775         if (developer_loading.integer)
6776                 Con_Printf("loading quake skin \"%s\"\n", name);
6777
6778         // 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)
6779         skinframe->qpixels = (unsigned char *)Mem_Alloc(r_main_mempool, width*height);
6780         memcpy(skinframe->qpixels, skindata, width*height);
6781         skinframe->qwidth = width;
6782         skinframe->qheight = height;
6783
6784         featuresmask = 0;
6785         for (i = 0;i < width * height;i++)
6786                 featuresmask |= palette_featureflags[skindata[i]];
6787
6788         skinframe->hasalpha = false;
6789         skinframe->qhascolormapping = loadpantsandshirt && (featuresmask & (PALETTEFEATURE_PANTS | PALETTEFEATURE_SHIRT));
6790         skinframe->qgeneratenmap = r_shadow_bumpscale_basetexture.value > 0;
6791         skinframe->qgeneratemerged = true;
6792         skinframe->qgeneratebase = skinframe->qhascolormapping;
6793         skinframe->qgenerateglow = loadglowtexture && (featuresmask & PALETTEFEATURE_GLOW);
6794
6795         R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, ((unsigned char *)palette_bgra_complete)[skindata[pix]*4 + comp]);
6796         //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]);
6797
6798         return skinframe;
6799 }
6800
6801 static void R_SkinFrame_GenerateTexturesFromQPixels(skinframe_t *skinframe, qboolean colormapped)
6802 {
6803         int width;
6804         int height;
6805         unsigned char *skindata;
6806
6807         if (!skinframe->qpixels)
6808                 return;
6809
6810         if (!skinframe->qhascolormapping)
6811                 colormapped = false;
6812
6813         if (colormapped)
6814         {
6815                 if (!skinframe->qgeneratebase)
6816                         return;
6817         }
6818         else
6819         {
6820                 if (!skinframe->qgeneratemerged)
6821                         return;
6822         }
6823
6824         width = skinframe->qwidth;
6825         height = skinframe->qheight;
6826         skindata = skinframe->qpixels;
6827
6828         if (skinframe->qgeneratenmap)
6829         {
6830                 unsigned char *temp1, *temp2;
6831                 skinframe->qgeneratenmap = false;
6832                 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
6833                 temp2 = temp1 + width * height * 4;
6834                 // use either a custom palette or the quake palette
6835                 Image_Copy8bitBGRA(skindata, temp1, width * height, palette_bgra_complete);
6836                 Image_HeightmapToNormalmap_BGRA(temp1, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
6837                 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);
6838                 Mem_Free(temp1);
6839         }
6840
6841         if (skinframe->qgenerateglow)
6842         {
6843                 skinframe->qgenerateglow = false;
6844                 skinframe->glow = R_LoadTexture2D(r_main_texturepool, va("%s_glow", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, -1, palette_bgra_onlyfullbrights); // glow
6845         }
6846
6847         if (colormapped)
6848         {
6849                 skinframe->qgeneratebase = false;
6850                 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);
6851                 skinframe->pants = R_LoadTexture2D(r_main_texturepool, va("%s_pants", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, -1, palette_bgra_pantsaswhite);
6852                 skinframe->shirt = R_LoadTexture2D(r_main_texturepool, va("%s_shirt", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, -1, palette_bgra_shirtaswhite);
6853         }
6854         else
6855         {
6856                 skinframe->qgeneratemerged = false;
6857                 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);
6858         }
6859
6860         if (!skinframe->qgeneratemerged && !skinframe->qgeneratebase)
6861         {
6862                 Mem_Free(skinframe->qpixels);
6863                 skinframe->qpixels = NULL;
6864         }
6865 }
6866
6867 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)
6868 {
6869         int i;
6870         skinframe_t *skinframe;
6871
6872         if (cls.state == ca_dedicated)
6873                 return NULL;
6874
6875         // if already loaded just return it, otherwise make a new skinframe
6876         skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height) : 0, true);
6877         if (skinframe && skinframe->base)
6878                 return skinframe;
6879
6880         skinframe->stain = NULL;
6881         skinframe->merged = NULL;
6882         skinframe->base = NULL;
6883         skinframe->pants = NULL;
6884         skinframe->shirt = NULL;
6885         skinframe->nmap = NULL;
6886         skinframe->gloss = NULL;
6887         skinframe->glow = NULL;
6888         skinframe->fog = NULL;
6889         skinframe->reflect = NULL;
6890         skinframe->hasalpha = false;
6891
6892         // if no data was provided, then clearly the caller wanted to get a blank skinframe
6893         if (!skindata)
6894                 return NULL;
6895
6896         if (developer_loading.integer)
6897                 Con_Printf("loading embedded 8bit image \"%s\"\n", name);
6898
6899         skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_PALETTE, textureflags, -1, palette);
6900         if (textureflags & TEXF_ALPHA)
6901         {
6902                 for (i = 0;i < width * height;i++)
6903                 {
6904                         if (((unsigned char *)palette)[skindata[i]*4+3] < 255)
6905                         {
6906                                 skinframe->hasalpha = true;
6907                                 break;
6908                         }
6909                 }
6910                 if (r_loadfog && skinframe->hasalpha)
6911                         skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, textureflags, -1, alphapalette);
6912         }
6913
6914         R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, ((unsigned char *)palette)[skindata[pix]*4 + comp]);
6915         //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]);
6916
6917         return skinframe;
6918 }
6919
6920 skinframe_t *R_SkinFrame_LoadMissing(void)
6921 {
6922         skinframe_t *skinframe;
6923
6924         if (cls.state == ca_dedicated)
6925                 return NULL;
6926
6927         skinframe = R_SkinFrame_Find("missing", TEXF_FORCENEAREST, 0, 0, 0, true);
6928         skinframe->stain = NULL;
6929         skinframe->merged = NULL;
6930         skinframe->base = NULL;
6931         skinframe->pants = NULL;
6932         skinframe->shirt = NULL;
6933         skinframe->nmap = NULL;
6934         skinframe->gloss = NULL;
6935         skinframe->glow = NULL;
6936         skinframe->fog = NULL;
6937         skinframe->reflect = NULL;
6938         skinframe->hasalpha = false;
6939
6940         skinframe->avgcolor[0] = rand() / RAND_MAX;
6941         skinframe->avgcolor[1] = rand() / RAND_MAX;
6942         skinframe->avgcolor[2] = rand() / RAND_MAX;
6943         skinframe->avgcolor[3] = 1;
6944
6945         return skinframe;
6946 }
6947
6948 //static char *suffix[6] = {"ft", "bk", "rt", "lf", "up", "dn"};
6949 typedef struct suffixinfo_s
6950 {
6951         const char *suffix;
6952         qboolean flipx, flipy, flipdiagonal;
6953 }
6954 suffixinfo_t;
6955 static suffixinfo_t suffix[3][6] =
6956 {
6957         {
6958                 {"px",   false, false, false},
6959                 {"nx",   false, false, false},
6960                 {"py",   false, false, false},
6961                 {"ny",   false, false, false},
6962                 {"pz",   false, false, false},
6963                 {"nz",   false, false, false}
6964         },
6965         {
6966                 {"posx", false, false, false},
6967                 {"negx", false, false, false},
6968                 {"posy", false, false, false},
6969                 {"negy", false, false, false},
6970                 {"posz", false, false, false},
6971                 {"negz", false, false, false}
6972         },
6973         {
6974                 {"rt",    true, false,  true},
6975                 {"lf",   false,  true,  true},
6976                 {"ft",    true,  true, false},
6977                 {"bk",   false, false, false},
6978                 {"up",    true, false,  true},
6979                 {"dn",    true, false,  true}
6980         }
6981 };
6982
6983 static int componentorder[4] = {0, 1, 2, 3};
6984
6985 rtexture_t *R_LoadCubemap(const char *basename)
6986 {
6987         int i, j, cubemapsize;
6988         unsigned char *cubemappixels, *image_buffer;
6989         rtexture_t *cubemaptexture;
6990         char name[256];
6991         // must start 0 so the first loadimagepixels has no requested width/height
6992         cubemapsize = 0;
6993         cubemappixels = NULL;
6994         cubemaptexture = NULL;
6995         // keep trying different suffix groups (posx, px, rt) until one loads
6996         for (j = 0;j < 3 && !cubemappixels;j++)
6997         {
6998                 // load the 6 images in the suffix group
6999                 for (i = 0;i < 6;i++)
7000                 {
7001                         // generate an image name based on the base and and suffix
7002                         dpsnprintf(name, sizeof(name), "%s%s", basename, suffix[j][i].suffix);
7003                         // load it
7004                         if ((image_buffer = loadimagepixelsbgra(name, false, false, r_texture_convertsRGB_cubemap.integer != 0, NULL)))
7005                         {
7006                                 // an image loaded, make sure width and height are equal
7007                                 if (image_width == image_height && (!cubemappixels || image_width == cubemapsize))
7008                                 {
7009                                         // if this is the first image to load successfully, allocate the cubemap memory
7010                                         if (!cubemappixels && image_width >= 1)
7011                                         {
7012                                                 cubemapsize = image_width;
7013                                                 // note this clears to black, so unavailable sides are black
7014                                                 cubemappixels = (unsigned char *)Mem_Alloc(tempmempool, 6*cubemapsize*cubemapsize*4);
7015                                         }
7016                                         // copy the image with any flipping needed by the suffix (px and posx types don't need flipping)
7017                                         if (cubemappixels)
7018                                                 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);
7019                                 }
7020                                 else
7021                                         Con_Printf("Cubemap image \"%s\" (%ix%i) is not square, OpenGL requires square cubemaps.\n", name, image_width, image_height);
7022                                 // free the image
7023                                 Mem_Free(image_buffer);
7024                         }
7025                 }
7026         }
7027         // if a cubemap loaded, upload it
7028         if (cubemappixels)
7029         {
7030                 if (developer_loading.integer)
7031                         Con_Printf("loading cubemap \"%s\"\n", basename);
7032
7033                 cubemaptexture = R_LoadTextureCubeMap(r_main_texturepool, basename, cubemapsize, cubemappixels, TEXTYPE_BGRA, (gl_texturecompression_lightcubemaps.integer ? TEXF_COMPRESS : 0) | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
7034                 Mem_Free(cubemappixels);
7035         }
7036         else
7037         {
7038                 Con_DPrintf("failed to load cubemap \"%s\"\n", basename);
7039                 if (developer_loading.integer)
7040                 {
7041                         Con_Printf("(tried tried images ");
7042                         for (j = 0;j < 3;j++)
7043                                 for (i = 0;i < 6;i++)
7044                                         Con_Printf("%s\"%s%s.tga\"", j + i > 0 ? ", " : "", basename, suffix[j][i].suffix);
7045                         Con_Print(" and was unable to find any of them).\n");
7046                 }
7047         }
7048         return cubemaptexture;
7049 }
7050
7051 rtexture_t *R_GetCubemap(const char *basename)
7052 {
7053         int i;
7054         for (i = 0;i < r_texture_numcubemaps;i++)
7055                 if (!strcasecmp(r_texture_cubemaps[i].basename, basename))
7056                         return r_texture_cubemaps[i].texture ? r_texture_cubemaps[i].texture : r_texture_whitecube;
7057         if (i >= MAX_CUBEMAPS)
7058                 return r_texture_whitecube;
7059         r_texture_numcubemaps++;
7060         strlcpy(r_texture_cubemaps[i].basename, basename, sizeof(r_texture_cubemaps[i].basename));
7061         r_texture_cubemaps[i].texture = R_LoadCubemap(r_texture_cubemaps[i].basename);
7062         return r_texture_cubemaps[i].texture;
7063 }
7064
7065 void R_FreeCubemaps(void)
7066 {
7067         int i;
7068         for (i = 0;i < r_texture_numcubemaps;i++)
7069         {
7070                 if (developer_loading.integer)
7071                         Con_DPrintf("unloading cubemap \"%s\"\n", r_texture_cubemaps[i].basename);
7072                 if (r_texture_cubemaps[i].texture)
7073                         R_FreeTexture(r_texture_cubemaps[i].texture);
7074         }
7075         r_texture_numcubemaps = 0;
7076 }
7077
7078 void R_Main_FreeViewCache(void)
7079 {
7080         if (r_refdef.viewcache.entityvisible)
7081                 Mem_Free(r_refdef.viewcache.entityvisible);
7082         if (r_refdef.viewcache.world_pvsbits)
7083                 Mem_Free(r_refdef.viewcache.world_pvsbits);
7084         if (r_refdef.viewcache.world_leafvisible)
7085                 Mem_Free(r_refdef.viewcache.world_leafvisible);
7086         if (r_refdef.viewcache.world_surfacevisible)
7087                 Mem_Free(r_refdef.viewcache.world_surfacevisible);
7088         memset(&r_refdef.viewcache, 0, sizeof(r_refdef.viewcache));
7089 }
7090
7091 void R_Main_ResizeViewCache(void)
7092 {
7093         int numentities = r_refdef.scene.numentities;
7094         int numclusters = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_pvsclusters : 1;
7095         int numclusterbytes = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_pvsclusterbytes : 1;
7096         int numleafs = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_leafs : 1;
7097         int numsurfaces = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->num_surfaces : 1;
7098         if (r_refdef.viewcache.maxentities < numentities)
7099         {
7100                 r_refdef.viewcache.maxentities = numentities;
7101                 if (r_refdef.viewcache.entityvisible)
7102                         Mem_Free(r_refdef.viewcache.entityvisible);
7103                 r_refdef.viewcache.entityvisible = (unsigned char *)Mem_Alloc(r_main_mempool, r_refdef.viewcache.maxentities);
7104         }
7105         if (r_refdef.viewcache.world_numclusters != numclusters)
7106         {
7107                 r_refdef.viewcache.world_numclusters = numclusters;
7108                 r_refdef.viewcache.world_numclusterbytes = numclusterbytes;
7109                 if (r_refdef.viewcache.world_pvsbits)
7110                         Mem_Free(r_refdef.viewcache.world_pvsbits);
7111                 r_refdef.viewcache.world_pvsbits = (unsigned char *)Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numclusterbytes);
7112         }
7113         if (r_refdef.viewcache.world_numleafs != numleafs)
7114         {
7115                 r_refdef.viewcache.world_numleafs = numleafs;
7116                 if (r_refdef.viewcache.world_leafvisible)
7117                         Mem_Free(r_refdef.viewcache.world_leafvisible);
7118                 r_refdef.viewcache.world_leafvisible = (unsigned char *)Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numleafs);
7119         }
7120         if (r_refdef.viewcache.world_numsurfaces != numsurfaces)
7121         {
7122                 r_refdef.viewcache.world_numsurfaces = numsurfaces;
7123                 if (r_refdef.viewcache.world_surfacevisible)
7124                         Mem_Free(r_refdef.viewcache.world_surfacevisible);
7125                 r_refdef.viewcache.world_surfacevisible = (unsigned char *)Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numsurfaces);
7126         }
7127 }
7128
7129 extern rtexture_t *loadingscreentexture;
7130 void gl_main_start(void)
7131 {
7132         loadingscreentexture = NULL;
7133         r_texture_blanknormalmap = NULL;
7134         r_texture_white = NULL;
7135         r_texture_grey128 = NULL;
7136         r_texture_black = NULL;
7137         r_texture_whitecube = NULL;
7138         r_texture_normalizationcube = NULL;
7139         r_texture_fogattenuation = NULL;
7140         r_texture_fogheighttexture = NULL;
7141         r_texture_gammaramps = NULL;
7142         r_texture_numcubemaps = 0;
7143
7144         r_loaddds = r_texture_dds_load.integer;
7145         r_savedds = vid.support.arb_texture_compression && vid.support.ext_texture_compression_s3tc && r_texture_dds_save.integer;
7146
7147         switch(vid.renderpath)
7148         {
7149         case RENDERPATH_GL20:
7150         case RENDERPATH_CGGL:
7151         case RENDERPATH_D3D9:
7152         case RENDERPATH_D3D10:
7153         case RENDERPATH_D3D11:
7154                 Cvar_SetValueQuick(&r_textureunits, vid.texunits);
7155                 Cvar_SetValueQuick(&gl_combine, 1);
7156                 Cvar_SetValueQuick(&r_glsl, 1);
7157                 r_loadnormalmap = true;
7158                 r_loadgloss = true;
7159                 r_loadfog = false;
7160                 break;
7161         case RENDERPATH_GL13:
7162                 Cvar_SetValueQuick(&r_textureunits, vid.texunits);
7163                 Cvar_SetValueQuick(&gl_combine, 1);
7164                 Cvar_SetValueQuick(&r_glsl, 0);
7165                 r_loadnormalmap = false;
7166                 r_loadgloss = false;
7167                 r_loadfog = true;
7168                 break;
7169         case RENDERPATH_GL11:
7170                 Cvar_SetValueQuick(&r_textureunits, vid.texunits);
7171                 Cvar_SetValueQuick(&gl_combine, 0);
7172                 Cvar_SetValueQuick(&r_glsl, 0);
7173                 r_loadnormalmap = false;
7174                 r_loadgloss = false;
7175                 r_loadfog = true;
7176                 break;
7177         }
7178
7179         R_AnimCache_Free();
7180         R_FrameData_Reset();
7181
7182         r_numqueries = 0;
7183         r_maxqueries = 0;
7184         memset(r_queries, 0, sizeof(r_queries));
7185
7186         r_qwskincache = NULL;
7187         r_qwskincache_size = 0;
7188
7189         // set up r_skinframe loading system for textures
7190         memset(&r_skinframe, 0, sizeof(r_skinframe));
7191         r_skinframe.loadsequence = 1;
7192         Mem_ExpandableArray_NewArray(&r_skinframe.array, r_main_mempool, sizeof(skinframe_t), 256);
7193
7194         r_main_texturepool = R_AllocTexturePool();
7195         R_BuildBlankTextures();
7196         R_BuildNoTexture();
7197         if (vid.support.arb_texture_cube_map)
7198         {
7199                 R_BuildWhiteCube();
7200                 R_BuildNormalizationCube();
7201         }
7202         r_texture_fogattenuation = NULL;
7203         r_texture_fogheighttexture = NULL;
7204         r_texture_gammaramps = NULL;
7205         //r_texture_fogintensity = NULL;
7206         memset(&r_bloomstate, 0, sizeof(r_bloomstate));
7207         memset(&r_waterstate, 0, sizeof(r_waterstate));
7208         r_glsl_permutation = NULL;
7209         memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash));
7210         Mem_ExpandableArray_NewArray(&r_glsl_permutationarray, r_main_mempool, sizeof(r_glsl_permutation_t), 256);
7211         glslshaderstring = NULL;
7212 #ifdef SUPPORTCG
7213         r_cg_permutation = NULL;
7214         memset(r_cg_permutationhash, 0, sizeof(r_cg_permutationhash));
7215         Mem_ExpandableArray_NewArray(&r_cg_permutationarray, r_main_mempool, sizeof(r_cg_permutation_t), 256);
7216         cgshaderstring = NULL;
7217 #endif
7218 #ifdef SUPPORTD3D
7219         r_hlsl_permutation = NULL;
7220         memset(r_hlsl_permutationhash, 0, sizeof(r_hlsl_permutationhash));
7221         Mem_ExpandableArray_NewArray(&r_hlsl_permutationarray, r_main_mempool, sizeof(r_hlsl_permutation_t), 256);
7222         hlslshaderstring = NULL;
7223 #endif
7224         memset(&r_svbsp, 0, sizeof (r_svbsp));
7225
7226         r_refdef.fogmasktable_density = 0;
7227 }
7228
7229 void gl_main_shutdown(void)
7230 {
7231         R_AnimCache_Free();
7232         R_FrameData_Reset();
7233
7234         R_Main_FreeViewCache();
7235
7236         switch(vid.renderpath)
7237         {
7238         case RENDERPATH_GL11:
7239         case RENDERPATH_GL13:
7240         case RENDERPATH_GL20:
7241         case RENDERPATH_CGGL:
7242                 if (r_maxqueries)
7243                         qglDeleteQueriesARB(r_maxqueries, r_queries);
7244                 break;
7245         case RENDERPATH_D3D9:
7246                 //Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
7247                 break;
7248         case RENDERPATH_D3D10:
7249                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
7250                 break;
7251         case RENDERPATH_D3D11:
7252                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
7253                 break;
7254         }
7255
7256         r_numqueries = 0;
7257         r_maxqueries = 0;
7258         memset(r_queries, 0, sizeof(r_queries));
7259
7260         r_qwskincache = NULL;
7261         r_qwskincache_size = 0;
7262
7263         // clear out the r_skinframe state
7264         Mem_ExpandableArray_FreeArray(&r_skinframe.array);
7265         memset(&r_skinframe, 0, sizeof(r_skinframe));
7266
7267         if (r_svbsp.nodes)
7268                 Mem_Free(r_svbsp.nodes);
7269         memset(&r_svbsp, 0, sizeof (r_svbsp));
7270         R_FreeTexturePool(&r_main_texturepool);
7271         loadingscreentexture = NULL;
7272         r_texture_blanknormalmap = NULL;
7273         r_texture_white = NULL;
7274         r_texture_grey128 = NULL;
7275         r_texture_black = NULL;
7276         r_texture_whitecube = NULL;
7277         r_texture_normalizationcube = NULL;
7278         r_texture_fogattenuation = NULL;
7279         r_texture_fogheighttexture = NULL;
7280         r_texture_gammaramps = NULL;
7281         r_texture_numcubemaps = 0;
7282         //r_texture_fogintensity = NULL;
7283         memset(&r_bloomstate, 0, sizeof(r_bloomstate));
7284         memset(&r_waterstate, 0, sizeof(r_waterstate));
7285         R_GLSL_Restart_f();
7286 }
7287
7288 extern void CL_ParseEntityLump(char *entitystring);
7289 void gl_main_newmap(void)
7290 {
7291         // FIXME: move this code to client
7292         char *entities, entname[MAX_QPATH];
7293         if (r_qwskincache)
7294                 Mem_Free(r_qwskincache);
7295         r_qwskincache = NULL;
7296         r_qwskincache_size = 0;
7297         if (cl.worldmodel)
7298         {
7299                 dpsnprintf(entname, sizeof(entname), "%s.ent", cl.worldnamenoextension);
7300                 if ((entities = (char *)FS_LoadFile(entname, tempmempool, true, NULL)))
7301                 {
7302                         CL_ParseEntityLump(entities);
7303                         Mem_Free(entities);
7304                         return;
7305                 }
7306                 if (cl.worldmodel->brush.entities)
7307                         CL_ParseEntityLump(cl.worldmodel->brush.entities);
7308         }
7309         R_Main_FreeViewCache();
7310
7311         R_FrameData_Reset();
7312 }
7313
7314 void GL_Main_Init(void)
7315 {
7316         r_main_mempool = Mem_AllocPool("Renderer", 0, NULL);
7317
7318         Cmd_AddCommand("r_glsl_restart", R_GLSL_Restart_f, "unloads GLSL shaders, they will then be reloaded as needed");
7319         Cmd_AddCommand("r_glsl_dumpshader", R_GLSL_DumpShader_f, "dumps the engine internal default.glsl shader into glsl/default.glsl");
7320         // FIXME: the client should set up r_refdef.fog stuff including the fogmasktable
7321         if (gamemode == GAME_NEHAHRA)
7322         {
7323                 Cvar_RegisterVariable (&gl_fogenable);
7324                 Cvar_RegisterVariable (&gl_fogdensity);
7325                 Cvar_RegisterVariable (&gl_fogred);
7326                 Cvar_RegisterVariable (&gl_foggreen);
7327                 Cvar_RegisterVariable (&gl_fogblue);
7328                 Cvar_RegisterVariable (&gl_fogstart);
7329                 Cvar_RegisterVariable (&gl_fogend);
7330                 Cvar_RegisterVariable (&gl_skyclip);
7331         }
7332         Cvar_RegisterVariable(&r_motionblur);
7333         Cvar_RegisterVariable(&r_motionblur_maxblur);
7334         Cvar_RegisterVariable(&r_motionblur_bmin);
7335         Cvar_RegisterVariable(&r_motionblur_vmin);
7336         Cvar_RegisterVariable(&r_motionblur_vmax);
7337         Cvar_RegisterVariable(&r_motionblur_vcoeff);
7338         Cvar_RegisterVariable(&r_motionblur_randomize);
7339         Cvar_RegisterVariable(&r_damageblur);
7340         Cvar_RegisterVariable(&r_equalize_entities_fullbright);
7341         Cvar_RegisterVariable(&r_equalize_entities_minambient);
7342         Cvar_RegisterVariable(&r_equalize_entities_by);
7343         Cvar_RegisterVariable(&r_equalize_entities_to);
7344         Cvar_RegisterVariable(&r_depthfirst);
7345         Cvar_RegisterVariable(&r_useinfinitefarclip);
7346         Cvar_RegisterVariable(&r_farclip_base);
7347         Cvar_RegisterVariable(&r_farclip_world);
7348         Cvar_RegisterVariable(&r_nearclip);
7349         Cvar_RegisterVariable(&r_showbboxes);
7350         Cvar_RegisterVariable(&r_showsurfaces);
7351         Cvar_RegisterVariable(&r_showtris);
7352         Cvar_RegisterVariable(&r_shownormals);
7353         Cvar_RegisterVariable(&r_showlighting);
7354         Cvar_RegisterVariable(&r_showshadowvolumes);
7355         Cvar_RegisterVariable(&r_showcollisionbrushes);
7356         Cvar_RegisterVariable(&r_showcollisionbrushes_polygonfactor);
7357         Cvar_RegisterVariable(&r_showcollisionbrushes_polygonoffset);
7358         Cvar_RegisterVariable(&r_showdisabledepthtest);
7359         Cvar_RegisterVariable(&r_drawportals);
7360         Cvar_RegisterVariable(&r_drawentities);
7361         Cvar_RegisterVariable(&r_draw2d);
7362         Cvar_RegisterVariable(&r_drawworld);
7363         Cvar_RegisterVariable(&r_cullentities_trace);
7364         Cvar_RegisterVariable(&r_cullentities_trace_samples);
7365         Cvar_RegisterVariable(&r_cullentities_trace_tempentitysamples);
7366         Cvar_RegisterVariable(&r_cullentities_trace_enlarge);
7367         Cvar_RegisterVariable(&r_cullentities_trace_delay);
7368         Cvar_RegisterVariable(&r_drawviewmodel);
7369         Cvar_RegisterVariable(&r_drawexteriormodel);
7370         Cvar_RegisterVariable(&r_speeds);
7371         Cvar_RegisterVariable(&r_fullbrights);
7372         Cvar_RegisterVariable(&r_wateralpha);
7373         Cvar_RegisterVariable(&r_dynamic);
7374         Cvar_RegisterVariable(&r_fakelight);
7375         Cvar_RegisterVariable(&r_fakelight_intensity);
7376         Cvar_RegisterVariable(&r_fullbright);
7377         Cvar_RegisterVariable(&r_shadows);
7378         Cvar_RegisterVariable(&r_shadows_darken);
7379         Cvar_RegisterVariable(&r_shadows_drawafterrtlighting);
7380         Cvar_RegisterVariable(&r_shadows_castfrombmodels);
7381         Cvar_RegisterVariable(&r_shadows_throwdistance);
7382         Cvar_RegisterVariable(&r_shadows_throwdirection);
7383         Cvar_RegisterVariable(&r_shadows_focus);
7384         Cvar_RegisterVariable(&r_shadows_shadowmapscale);
7385         Cvar_RegisterVariable(&r_q1bsp_skymasking);
7386         Cvar_RegisterVariable(&r_polygonoffset_submodel_factor);
7387         Cvar_RegisterVariable(&r_polygonoffset_submodel_offset);
7388         Cvar_RegisterVariable(&r_polygonoffset_decals_factor);
7389         Cvar_RegisterVariable(&r_polygonoffset_decals_offset);
7390         Cvar_RegisterVariable(&r_fog_exp2);
7391         Cvar_RegisterVariable(&r_drawfog);
7392         Cvar_RegisterVariable(&r_transparentdepthmasking);
7393         Cvar_RegisterVariable(&r_texture_dds_load);
7394         Cvar_RegisterVariable(&r_texture_dds_save);
7395         Cvar_RegisterVariable(&r_texture_convertsRGB_2d);
7396         Cvar_RegisterVariable(&r_texture_convertsRGB_skin);
7397         Cvar_RegisterVariable(&r_texture_convertsRGB_cubemap);
7398         Cvar_RegisterVariable(&r_texture_convertsRGB_skybox);
7399         Cvar_RegisterVariable(&r_texture_convertsRGB_particles);
7400         Cvar_RegisterVariable(&r_textureunits);
7401         Cvar_RegisterVariable(&gl_combine);
7402         Cvar_RegisterVariable(&r_glsl);
7403         Cvar_RegisterVariable(&r_glsl_deluxemapping);
7404         Cvar_RegisterVariable(&r_glsl_offsetmapping);
7405         Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping);
7406         Cvar_RegisterVariable(&r_glsl_offsetmapping_scale);
7407         Cvar_RegisterVariable(&r_glsl_postprocess);
7408         Cvar_RegisterVariable(&r_glsl_postprocess_uservec1);
7409         Cvar_RegisterVariable(&r_glsl_postprocess_uservec2);
7410         Cvar_RegisterVariable(&r_glsl_postprocess_uservec3);
7411         Cvar_RegisterVariable(&r_glsl_postprocess_uservec4);
7412         Cvar_RegisterVariable(&r_glsl_postprocess_uservec1_enable);
7413         Cvar_RegisterVariable(&r_glsl_postprocess_uservec2_enable);
7414         Cvar_RegisterVariable(&r_glsl_postprocess_uservec3_enable);
7415         Cvar_RegisterVariable(&r_glsl_postprocess_uservec4_enable);
7416
7417         Cvar_RegisterVariable(&r_water);
7418         Cvar_RegisterVariable(&r_water_resolutionmultiplier);
7419         Cvar_RegisterVariable(&r_water_clippingplanebias);
7420         Cvar_RegisterVariable(&r_water_refractdistort);
7421         Cvar_RegisterVariable(&r_water_reflectdistort);
7422         Cvar_RegisterVariable(&r_water_scissormode);
7423         Cvar_RegisterVariable(&r_lerpsprites);
7424         Cvar_RegisterVariable(&r_lerpmodels);
7425         Cvar_RegisterVariable(&r_lerplightstyles);
7426         Cvar_RegisterVariable(&r_waterscroll);
7427         Cvar_RegisterVariable(&r_bloom);
7428         Cvar_RegisterVariable(&r_bloom_colorscale);
7429         Cvar_RegisterVariable(&r_bloom_brighten);
7430         Cvar_RegisterVariable(&r_bloom_blur);
7431         Cvar_RegisterVariable(&r_bloom_resolution);
7432         Cvar_RegisterVariable(&r_bloom_colorexponent);
7433         Cvar_RegisterVariable(&r_bloom_colorsubtract);
7434         Cvar_RegisterVariable(&r_hdr);
7435         Cvar_RegisterVariable(&r_hdr_scenebrightness);
7436         Cvar_RegisterVariable(&r_hdr_glowintensity);
7437         Cvar_RegisterVariable(&r_hdr_range);
7438         Cvar_RegisterVariable(&r_smoothnormals_areaweighting);
7439         Cvar_RegisterVariable(&developer_texturelogging);
7440         Cvar_RegisterVariable(&gl_lightmaps);
7441         Cvar_RegisterVariable(&r_test);
7442         Cvar_RegisterVariable(&r_glsl_saturation);
7443         Cvar_RegisterVariable(&r_glsl_saturation_redcompensate);
7444         Cvar_RegisterVariable(&r_framedatasize);
7445         if (gamemode == GAME_NEHAHRA || gamemode == GAME_TENEBRAE)
7446                 Cvar_SetValue("r_fullbrights", 0);
7447         R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap, NULL, NULL);
7448
7449         Cvar_RegisterVariable(&r_track_sprites);
7450         Cvar_RegisterVariable(&r_track_sprites_flags);
7451         Cvar_RegisterVariable(&r_track_sprites_scalew);
7452         Cvar_RegisterVariable(&r_track_sprites_scaleh);
7453         Cvar_RegisterVariable(&r_overheadsprites_perspective);
7454         Cvar_RegisterVariable(&r_overheadsprites_pushback);
7455         Cvar_RegisterVariable(&r_overheadsprites_scalex);
7456         Cvar_RegisterVariable(&r_overheadsprites_scaley);
7457 }
7458
7459 extern void R_Textures_Init(void);
7460 extern void GL_Draw_Init(void);
7461 extern void GL_Main_Init(void);
7462 extern void R_Shadow_Init(void);
7463 extern void R_Sky_Init(void);
7464 extern void GL_Surf_Init(void);
7465 extern void R_Particles_Init(void);
7466 extern void R_Explosion_Init(void);
7467 extern void gl_backend_init(void);
7468 extern void Sbar_Init(void);
7469 extern void R_LightningBeams_Init(void);
7470 extern void Mod_RenderInit(void);
7471 extern void Font_Init(void);
7472
7473 void Render_Init(void)
7474 {
7475         gl_backend_init();
7476         R_Textures_Init();
7477         GL_Main_Init();
7478         Font_Init();
7479         GL_Draw_Init();
7480         R_Shadow_Init();
7481         R_Sky_Init();
7482         GL_Surf_Init();
7483         Sbar_Init();
7484         R_Particles_Init();
7485         R_Explosion_Init();
7486         R_LightningBeams_Init();
7487         Mod_RenderInit();
7488 }
7489
7490 /*
7491 ===============
7492 GL_Init
7493 ===============
7494 */
7495 extern char *ENGINE_EXTENSIONS;
7496 void GL_Init (void)
7497 {
7498         gl_renderer = (const char *)qglGetString(GL_RENDERER);
7499         gl_vendor = (const char *)qglGetString(GL_VENDOR);
7500         gl_version = (const char *)qglGetString(GL_VERSION);
7501         gl_extensions = (const char *)qglGetString(GL_EXTENSIONS);
7502
7503         if (!gl_extensions)
7504                 gl_extensions = "";
7505         if (!gl_platformextensions)
7506                 gl_platformextensions = "";
7507
7508         Con_Printf("GL_VENDOR: %s\n", gl_vendor);
7509         Con_Printf("GL_RENDERER: %s\n", gl_renderer);
7510         Con_Printf("GL_VERSION: %s\n", gl_version);
7511         Con_DPrintf("GL_EXTENSIONS: %s\n", gl_extensions);
7512         Con_DPrintf("%s_EXTENSIONS: %s\n", gl_platform, gl_platformextensions);
7513
7514         VID_CheckExtensions();
7515
7516         // LordHavoc: report supported extensions
7517         Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
7518
7519         // clear to black (loading plaque will be seen over this)
7520         GL_Clear(GL_COLOR_BUFFER_BIT, NULL, 1.0f, 128);
7521 }
7522
7523 int R_CullBox(const vec3_t mins, const vec3_t maxs)
7524 {
7525         int i;
7526         mplane_t *p;
7527         for (i = 0;i < r_refdef.view.numfrustumplanes;i++)
7528         {
7529                 // skip nearclip plane, it often culls portals when you are very close, and is almost never useful
7530                 if (i == 4)
7531                         continue;
7532                 p = r_refdef.view.frustum + i;
7533                 switch(p->signbits)
7534                 {
7535                 default:
7536                 case 0:
7537                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
7538                                 return true;
7539                         break;
7540                 case 1:
7541                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
7542                                 return true;
7543                         break;
7544                 case 2:
7545                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
7546                                 return true;
7547                         break;
7548                 case 3:
7549                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
7550                                 return true;
7551                         break;
7552                 case 4:
7553                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
7554                                 return true;
7555                         break;
7556                 case 5:
7557                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
7558                                 return true;
7559                         break;
7560                 case 6:
7561                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
7562                                 return true;
7563                         break;
7564                 case 7:
7565                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
7566                                 return true;
7567                         break;
7568                 }
7569         }
7570         return false;
7571 }
7572
7573 int R_CullBoxCustomPlanes(const vec3_t mins, const vec3_t maxs, int numplanes, const mplane_t *planes)
7574 {
7575         int i;
7576         const mplane_t *p;
7577         for (i = 0;i < numplanes;i++)
7578         {
7579                 p = planes + i;
7580                 switch(p->signbits)
7581                 {
7582                 default:
7583                 case 0:
7584                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
7585                                 return true;
7586                         break;
7587                 case 1:
7588                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
7589                                 return true;
7590                         break;
7591                 case 2:
7592                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
7593                                 return true;
7594                         break;
7595                 case 3:
7596                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
7597                                 return true;
7598                         break;
7599                 case 4:
7600                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
7601                                 return true;
7602                         break;
7603                 case 5:
7604                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
7605                                 return true;
7606                         break;
7607                 case 6:
7608                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
7609                                 return true;
7610                         break;
7611                 case 7:
7612                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
7613                                 return true;
7614                         break;
7615                 }
7616         }
7617         return false;
7618 }
7619
7620 //==================================================================================
7621
7622 // LordHavoc: this stores temporary data used within the same frame
7623
7624 qboolean r_framedata_failed;
7625 static size_t r_framedata_size;
7626 static size_t r_framedata_current;
7627 static void *r_framedata_base;
7628
7629 void R_FrameData_Reset(void)
7630 {
7631         if (r_framedata_base)
7632                 Mem_Free(r_framedata_base);
7633         r_framedata_base = NULL;
7634         r_framedata_size = 0;
7635         r_framedata_current = 0;
7636         r_framedata_failed = false;
7637 }
7638
7639 void R_FrameData_NewFrame(void)
7640 {
7641         size_t wantedsize;
7642         if (r_framedata_failed)
7643                 Cvar_SetValueQuick(&r_framedatasize, r_framedatasize.value + 1.0f);
7644         wantedsize = (size_t)(r_framedatasize.value * 1024*1024);
7645         wantedsize = bound(65536, wantedsize, 128*1024*1024);
7646         if (r_framedata_size != wantedsize)
7647         {
7648                 r_framedata_size = wantedsize;
7649                 if (r_framedata_base)
7650                         Mem_Free(r_framedata_base);
7651                 r_framedata_base = Mem_Alloc(r_main_mempool, r_framedata_size);
7652         }
7653         r_framedata_current = 0;
7654         r_framedata_failed = false;
7655 }
7656
7657 void *R_FrameData_Alloc(size_t size)
7658 {
7659         void *data;
7660
7661         // align to 16 byte boundary
7662         size = (size + 15) & ~15;
7663         data = (void *)((unsigned char*)r_framedata_base + r_framedata_current);
7664         r_framedata_current += size;
7665
7666         // check overflow
7667         if (r_framedata_current > r_framedata_size)
7668                 r_framedata_failed = true;
7669
7670         // return NULL on everything after a failure
7671         if (r_framedata_failed)
7672                 return NULL;
7673
7674         return data;
7675 }
7676
7677 void *R_FrameData_Store(size_t size, void *data)
7678 {
7679         void *d = R_FrameData_Alloc(size);
7680         if (d)
7681                 memcpy(d, data, size);
7682         return d;
7683 }
7684
7685 //==================================================================================
7686
7687 // LordHavoc: animcache originally written by Echon, rewritten since then
7688
7689 /**
7690  * Animation cache prevents re-generating mesh data for an animated model
7691  * multiple times in one frame for lighting, shadowing, reflections, etc.
7692  */
7693
7694 void R_AnimCache_Free(void)
7695 {
7696 }
7697
7698 void R_AnimCache_ClearCache(void)
7699 {
7700         int i;
7701         entity_render_t *ent;
7702
7703         for (i = 0;i < r_refdef.scene.numentities;i++)
7704         {
7705                 ent = r_refdef.scene.entities[i];
7706                 ent->animcache_vertex3f = NULL;
7707                 ent->animcache_normal3f = NULL;
7708                 ent->animcache_svector3f = NULL;
7709                 ent->animcache_tvector3f = NULL;
7710                 ent->animcache_vertexposition = NULL;
7711                 ent->animcache_vertexmesh = NULL;
7712                 ent->animcache_vertexpositionbuffer = NULL;
7713                 ent->animcache_vertexmeshbuffer = NULL;
7714         }
7715 }
7716
7717 void R_AnimCache_UpdateEntityMeshBuffers(entity_render_t *ent, int numvertices)
7718 {
7719         int i;
7720
7721         // identical memory layout, so no need to allocate...
7722         // this also provides the vertexposition structure to everything, e.g.
7723         // depth masked rendering currently uses it even if having separate
7724         // arrays
7725         // NOTE: get rid of this optimization if changing it to e.g. 4f
7726         ent->animcache_vertexposition = (r_vertexposition_t *)ent->animcache_vertex3f;
7727
7728         // TODO:
7729         // get rid of following uses of VERTEXPOSITION, change to the array:
7730         // R_DrawTextureSurfaceList_Sky if skyrendermasked
7731         // R_DrawSurface_TransparentCallback if r_transparentdepthmasking.integer
7732         // R_DrawTextureSurfaceList_DepthOnly
7733         // R_Q1BSP_DrawShadowMap
7734
7735         switch(vid.renderpath)
7736         {
7737         case RENDERPATH_GL20:
7738         case RENDERPATH_CGGL:
7739                 // need the meshbuffers if !gl_mesh_separatearrays.integer
7740                 if (gl_mesh_separatearrays.integer)
7741                         return;
7742                 break;
7743         case RENDERPATH_D3D9:
7744         case RENDERPATH_D3D10:
7745         case RENDERPATH_D3D11:
7746                 // always need the meshbuffers
7747                 break;
7748         case RENDERPATH_GL13:
7749         case RENDERPATH_GL11:
7750                 // never need the meshbuffers
7751                 return;
7752         }
7753
7754         if (!ent->animcache_vertexmesh && ent->animcache_normal3f)
7755                 ent->animcache_vertexmesh = (r_vertexmesh_t *)R_FrameData_Alloc(sizeof(r_vertexmesh_t)*numvertices);
7756         /*
7757         if (!ent->animcache_vertexposition)
7758                 ent->animcache_vertexposition = (r_vertexposition_t *)R_FrameData_Alloc(sizeof(r_vertexposition_t)*numvertices);
7759         */
7760         if (ent->animcache_vertexposition)
7761         {
7762                 /*
7763                 for (i = 0;i < numvertices;i++)
7764                         memcpy(ent->animcache_vertexposition[i].vertex3f, ent->animcache_vertex3f + 3*i, sizeof(float[3]));
7765                 */
7766                 // TODO: upload vertex buffer?
7767         }
7768         if (ent->animcache_vertexmesh)
7769         {
7770                 memcpy(ent->animcache_vertexmesh, ent->model->surfmesh.vertexmesh, sizeof(r_vertexmesh_t)*numvertices);
7771                 for (i = 0;i < numvertices;i++)
7772                         memcpy(ent->animcache_vertexmesh[i].vertex3f, ent->animcache_vertex3f + 3*i, sizeof(float[3]));
7773                 if (ent->animcache_svector3f)
7774                         for (i = 0;i < numvertices;i++)
7775                                 memcpy(ent->animcache_vertexmesh[i].svector3f, ent->animcache_svector3f + 3*i, sizeof(float[3]));
7776                 if (ent->animcache_tvector3f)
7777                         for (i = 0;i < numvertices;i++)
7778                                 memcpy(ent->animcache_vertexmesh[i].tvector3f, ent->animcache_tvector3f + 3*i, sizeof(float[3]));
7779                 if (ent->animcache_normal3f)
7780                         for (i = 0;i < numvertices;i++)
7781                                 memcpy(ent->animcache_vertexmesh[i].normal3f, ent->animcache_normal3f + 3*i, sizeof(float[3]));
7782                 // TODO: upload vertex buffer?
7783         }
7784 }
7785
7786 qboolean R_AnimCache_GetEntity(entity_render_t *ent, qboolean wantnormals, qboolean wanttangents)
7787 {
7788         dp_model_t *model = ent->model;
7789         int numvertices;
7790         // see if it's already cached this frame
7791         if (ent->animcache_vertex3f)
7792         {
7793                 // add normals/tangents if needed (this only happens with multiple views, reflections, cameras, etc)
7794                 if (wantnormals || wanttangents)
7795                 {
7796                         if (ent->animcache_normal3f)
7797                                 wantnormals = false;
7798                         if (ent->animcache_svector3f)
7799                                 wanttangents = false;
7800                         if (wantnormals || wanttangents)
7801                         {
7802                                 numvertices = model->surfmesh.num_vertices;
7803                                 if (wantnormals)
7804                                         ent->animcache_normal3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
7805                                 if (wanttangents)
7806                                 {
7807                                         ent->animcache_svector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
7808                                         ent->animcache_tvector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
7809                                 }
7810                                 if (!r_framedata_failed)
7811                                 {
7812                                         model->AnimateVertices(model, ent->frameblend, ent->skeleton, NULL, wantnormals ? ent->animcache_normal3f : NULL, wanttangents ? ent->animcache_svector3f : NULL, wanttangents ? ent->animcache_tvector3f : NULL);
7813                                         R_AnimCache_UpdateEntityMeshBuffers(ent, model->surfmesh.num_vertices);
7814                                 }
7815                         }
7816                 }
7817         }
7818         else
7819         {
7820                 // see if this ent is worth caching
7821                 if (!model || !model->Draw || !model->surfmesh.isanimated || !model->AnimateVertices || (ent->frameblend[0].lerp == 1 && ent->frameblend[0].subframe == 0 && !ent->skeleton))
7822                         return false;
7823                 // get some memory for this entity and generate mesh data
7824                 numvertices = model->surfmesh.num_vertices;
7825                 ent->animcache_vertex3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
7826                 if (wantnormals)
7827                         ent->animcache_normal3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
7828                 if (wanttangents)
7829                 {
7830                         ent->animcache_svector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
7831                         ent->animcache_tvector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
7832                 }
7833                 if (!r_framedata_failed)
7834                 {
7835                         model->AnimateVertices(model, ent->frameblend, ent->skeleton, ent->animcache_vertex3f, ent->animcache_normal3f, ent->animcache_svector3f, ent->animcache_tvector3f);
7836                         R_AnimCache_UpdateEntityMeshBuffers(ent, model->surfmesh.num_vertices);
7837                 }
7838         }
7839         return !r_framedata_failed;
7840 }
7841
7842 void R_AnimCache_CacheVisibleEntities(void)
7843 {
7844         int i;
7845         qboolean wantnormals = true;
7846         qboolean wanttangents = !r_showsurfaces.integer;
7847
7848         switch(vid.renderpath)
7849         {
7850         case RENDERPATH_GL20:
7851         case RENDERPATH_CGGL:
7852         case RENDERPATH_D3D9:
7853         case RENDERPATH_D3D10:
7854         case RENDERPATH_D3D11:
7855                 break;
7856         case RENDERPATH_GL13:
7857         case RENDERPATH_GL11:
7858                 wanttangents = false;
7859                 break;
7860         }
7861
7862         if (r_shownormals.integer)
7863                 wanttangents = wantnormals = true;
7864
7865         // TODO: thread this
7866         // NOTE: R_PrepareRTLights() also caches entities
7867
7868         for (i = 0;i < r_refdef.scene.numentities;i++)
7869                 if (r_refdef.viewcache.entityvisible[i])
7870                         R_AnimCache_GetEntity(r_refdef.scene.entities[i], wantnormals, wanttangents);
7871 }
7872
7873 //==================================================================================
7874
7875 static void R_View_UpdateEntityLighting (void)
7876 {
7877         int i;
7878         entity_render_t *ent;
7879         vec3_t tempdiffusenormal, avg;
7880         vec_t f, fa, fd, fdd;
7881         qboolean skipunseen = r_shadows.integer != 1; //|| R_Shadow_ShadowMappingEnabled();
7882
7883         for (i = 0;i < r_refdef.scene.numentities;i++)
7884         {
7885                 ent = r_refdef.scene.entities[i];
7886
7887                 // skip unseen models
7888                 if (!r_refdef.viewcache.entityvisible[i] && skipunseen)
7889                         continue;
7890
7891                 // skip bsp models
7892                 if (ent->model && ent->model->brush.num_leafs)
7893                 {
7894                         // TODO: use modellight for r_ambient settings on world?
7895                         VectorSet(ent->modellight_ambient, 0, 0, 0);
7896                         VectorSet(ent->modellight_diffuse, 0, 0, 0);
7897                         VectorSet(ent->modellight_lightdir, 0, 0, 1);
7898                         continue;
7899                 }
7900
7901                 // fetch the lighting from the worldmodel data
7902                 VectorClear(ent->modellight_ambient);
7903                 VectorClear(ent->modellight_diffuse);
7904                 VectorClear(tempdiffusenormal);
7905                 if ((ent->flags & RENDER_LIGHT) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.LightPoint)
7906                 {
7907                         vec3_t org;
7908                         Matrix4x4_OriginFromMatrix(&ent->matrix, org);
7909
7910                         // complete lightning for lit sprites
7911                         // todo: make a EF_ field so small ents could be lit purely by modellight and skipping real rtlight pass (like EF_NORTLIGHT)?
7912                         if (ent->model->type == mod_sprite && !(ent->model->data_textures[0].basematerialflags & MATERIALFLAG_FULLBRIGHT))
7913                         {
7914                                 if (ent->model->sprite.sprnum_type == SPR_OVERHEAD) // apply offset for overhead sprites
7915                                         org[2] = org[2] + r_overheadsprites_pushback.value;
7916                                 R_CompleteLightPoint(ent->modellight_ambient, ent->modellight_diffuse, ent->modellight_lightdir, org, LP_LIGHTMAP | LP_RTWORLD | LP_DYNLIGHT);
7917                         }
7918                         else
7919                                 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, org, ent->modellight_ambient, ent->modellight_diffuse, tempdiffusenormal);
7920
7921                         if(ent->flags & RENDER_EQUALIZE)
7922                         {
7923                                 // first fix up ambient lighting...
7924                                 if(r_equalize_entities_minambient.value > 0)
7925                                 {
7926                                         fd = 0.299f * ent->modellight_diffuse[0] + 0.587f * ent->modellight_diffuse[1] + 0.114f * ent->modellight_diffuse[2];
7927                                         if(fd > 0)
7928                                         {
7929                                                 fa = (0.299f * ent->modellight_ambient[0] + 0.587f * ent->modellight_ambient[1] + 0.114f * ent->modellight_ambient[2]);
7930                                                 if(fa < r_equalize_entities_minambient.value * fd)
7931                                                 {
7932                                                         // solve:
7933                                                         //   fa'/fd' = minambient
7934                                                         //   fa'+0.25*fd' = fa+0.25*fd
7935                                                         //   ...
7936                                                         //   fa' = fd' * minambient
7937                                                         //   fd'*(0.25+minambient) = fa+0.25*fd
7938                                                         //   ...
7939                                                         //   fd' = (fa+0.25*fd) * 1 / (0.25+minambient)
7940                                                         //   fa' = (fa+0.25*fd) * minambient / (0.25+minambient)
7941                                                         //   ...
7942                                                         fdd = (fa + 0.25f * fd) / (0.25f + r_equalize_entities_minambient.value);
7943                                                         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
7944                                                         VectorMA(ent->modellight_ambient, (1-f)*0.25f, ent->modellight_diffuse, ent->modellight_ambient);
7945                                                         VectorScale(ent->modellight_diffuse, f, ent->modellight_diffuse);
7946                                                 }
7947                                         }
7948                                 }
7949
7950                                 if(r_equalize_entities_to.value > 0 && r_equalize_entities_by.value != 0)
7951                                 {
7952                                         fa = 0.299f * ent->modellight_ambient[0] + 0.587f * ent->modellight_ambient[1] + 0.114f * ent->modellight_ambient[2];
7953                                         fd = 0.299f * ent->modellight_diffuse[0] + 0.587f * ent->modellight_diffuse[1] + 0.114f * ent->modellight_diffuse[2];
7954                                         f = fa + 0.25 * fd;
7955                                         if(f > 0)
7956                                         {
7957                                                 // adjust brightness and saturation to target
7958                                                 avg[0] = avg[1] = avg[2] = fa / f;
7959                                                 VectorLerp(ent->modellight_ambient, r_equalize_entities_by.value, avg, ent->modellight_ambient);
7960                                                 avg[0] = avg[1] = avg[2] = fd / f;
7961                                                 VectorLerp(ent->modellight_diffuse, r_equalize_entities_by.value, avg, ent->modellight_diffuse);
7962                                         }
7963                                 }
7964                         }
7965                 }
7966                 else // highly rare
7967                         VectorSet(ent->modellight_ambient, 1, 1, 1);
7968
7969                 // move the light direction into modelspace coordinates for lighting code
7970                 Matrix4x4_Transform3x3(&ent->inversematrix, tempdiffusenormal, ent->modellight_lightdir);
7971                 if(VectorLength2(ent->modellight_lightdir) == 0)
7972                         VectorSet(ent->modellight_lightdir, 0, 0, 1); // have to set SOME valid vector here
7973                 VectorNormalize(ent->modellight_lightdir);
7974         }
7975 }
7976
7977 #define MAX_LINEOFSIGHTTRACES 64
7978
7979 static qboolean R_CanSeeBox(int numsamples, vec_t enlarge, vec3_t eye, vec3_t entboxmins, vec3_t entboxmaxs)
7980 {
7981         int i;
7982         vec3_t boxmins, boxmaxs;
7983         vec3_t start;
7984         vec3_t end;
7985         dp_model_t *model = r_refdef.scene.worldmodel;
7986
7987         if (!model || !model->brush.TraceLineOfSight)
7988                 return true;
7989
7990         // expand the box a little
7991         boxmins[0] = (enlarge+1) * entboxmins[0] - enlarge * entboxmaxs[0];
7992         boxmaxs[0] = (enlarge+1) * entboxmaxs[0] - enlarge * entboxmins[0];
7993         boxmins[1] = (enlarge+1) * entboxmins[1] - enlarge * entboxmaxs[1];
7994         boxmaxs[1] = (enlarge+1) * entboxmaxs[1] - enlarge * entboxmins[1];
7995         boxmins[2] = (enlarge+1) * entboxmins[2] - enlarge * entboxmaxs[2];
7996         boxmaxs[2] = (enlarge+1) * entboxmaxs[2] - enlarge * entboxmins[2];
7997
7998         // return true if eye is inside enlarged box
7999         if (BoxesOverlap(boxmins, boxmaxs, eye, eye))
8000                 return true;
8001
8002         // try center
8003         VectorCopy(eye, start);
8004         VectorMAM(0.5f, boxmins, 0.5f, boxmaxs, end);
8005         if (model->brush.TraceLineOfSight(model, start, end))
8006                 return true;
8007
8008         // try various random positions
8009         for (i = 0;i < numsamples;i++)
8010         {
8011                 VectorSet(end, lhrandom(boxmins[0], boxmaxs[0]), lhrandom(boxmins[1], boxmaxs[1]), lhrandom(boxmins[2], boxmaxs[2]));
8012                 if (model->brush.TraceLineOfSight(model, start, end))
8013                         return true;
8014         }
8015
8016         return false;
8017 }
8018
8019
8020 static void R_View_UpdateEntityVisible (void)
8021 {
8022         int i;
8023         int renderimask;
8024         int samples;
8025         entity_render_t *ent;
8026
8027         renderimask = r_refdef.envmap                                    ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL)
8028                 : r_waterstate.renderingrefraction                       ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL)
8029                 : (chase_active.integer || r_waterstate.renderingscene)  ? RENDER_VIEWMODEL
8030                 :                                                          RENDER_EXTERIORMODEL;
8031         if (!r_drawviewmodel.integer)
8032                 renderimask |= RENDER_VIEWMODEL;
8033         if (!r_drawexteriormodel.integer)
8034                 renderimask |= RENDER_EXTERIORMODEL;
8035         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs)
8036         {
8037                 // worldmodel can check visibility
8038                 memset(r_refdef.viewcache.entityvisible, 0, r_refdef.scene.numentities);
8039                 for (i = 0;i < r_refdef.scene.numentities;i++)
8040                 {
8041                         ent = r_refdef.scene.entities[i];
8042                         if (!(ent->flags & renderimask))
8043                         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)))
8044                         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))
8045                                 r_refdef.viewcache.entityvisible[i] = true;
8046                 }
8047                 if(r_cullentities_trace.integer && r_refdef.scene.worldmodel->brush.TraceLineOfSight && !r_refdef.view.useclipplane)
8048                         // sorry, this check doesn't work for portal/reflection/refraction renders as the view origin is not useful for culling
8049                 {
8050                         for (i = 0;i < r_refdef.scene.numentities;i++)
8051                         {
8052                                 ent = r_refdef.scene.entities[i];
8053                                 if(r_refdef.viewcache.entityvisible[i] && !(ent->flags & (RENDER_VIEWMODEL | RENDER_NOCULL | RENDER_NODEPTHTEST)) && !(ent->model && (ent->model->name[0] == '*')))
8054                                 {
8055                                         samples = ent->entitynumber ? r_cullentities_trace_samples.integer : r_cullentities_trace_tempentitysamples.integer;
8056                                         if (samples < 0)
8057                                                 continue; // temp entities do pvs only
8058                                         if(R_CanSeeBox(samples, r_cullentities_trace_enlarge.value, r_refdef.view.origin, ent->mins, ent->maxs))
8059                                                 ent->last_trace_visibility = realtime;
8060                                         if(ent->last_trace_visibility < realtime - r_cullentities_trace_delay.value)
8061                                                 r_refdef.viewcache.entityvisible[i] = 0;
8062                                 }
8063                         }
8064                 }
8065         }
8066         else
8067         {
8068                 // no worldmodel or it can't check visibility
8069                 for (i = 0;i < r_refdef.scene.numentities;i++)
8070                 {
8071                         ent = r_refdef.scene.entities[i];
8072                         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));
8073                 }
8074         }
8075 }
8076
8077 /// only used if skyrendermasked, and normally returns false
8078 int R_DrawBrushModelsSky (void)
8079 {
8080         int i, sky;
8081         entity_render_t *ent;
8082
8083         sky = false;
8084         for (i = 0;i < r_refdef.scene.numentities;i++)
8085         {
8086                 if (!r_refdef.viewcache.entityvisible[i])
8087                         continue;
8088                 ent = r_refdef.scene.entities[i];
8089                 if (!ent->model || !ent->model->DrawSky)
8090                         continue;
8091                 ent->model->DrawSky(ent);
8092                 sky = true;
8093         }
8094         return sky;
8095 }
8096
8097 static void R_DrawNoModel(entity_render_t *ent);
8098 static void R_DrawModels(void)
8099 {
8100         int i;
8101         entity_render_t *ent;
8102
8103         for (i = 0;i < r_refdef.scene.numentities;i++)
8104         {
8105                 if (!r_refdef.viewcache.entityvisible[i])
8106                         continue;
8107                 ent = r_refdef.scene.entities[i];
8108                 r_refdef.stats.entities++;
8109                 if (ent->model && ent->model->Draw != NULL)
8110                         ent->model->Draw(ent);
8111                 else
8112                         R_DrawNoModel(ent);
8113         }
8114 }
8115
8116 static void R_DrawModelsDepth(void)
8117 {
8118         int i;
8119         entity_render_t *ent;
8120
8121         for (i = 0;i < r_refdef.scene.numentities;i++)
8122         {
8123                 if (!r_refdef.viewcache.entityvisible[i])
8124                         continue;
8125                 ent = r_refdef.scene.entities[i];
8126                 if (ent->model && ent->model->DrawDepth != NULL)
8127                         ent->model->DrawDepth(ent);
8128         }
8129 }
8130
8131 static void R_DrawModelsDebug(void)
8132 {
8133         int i;
8134         entity_render_t *ent;
8135
8136         for (i = 0;i < r_refdef.scene.numentities;i++)
8137         {
8138                 if (!r_refdef.viewcache.entityvisible[i])
8139                         continue;
8140                 ent = r_refdef.scene.entities[i];
8141                 if (ent->model && ent->model->DrawDebug != NULL)
8142                         ent->model->DrawDebug(ent);
8143         }
8144 }
8145
8146 static void R_DrawModelsAddWaterPlanes(void)
8147 {
8148         int i;
8149         entity_render_t *ent;
8150
8151         for (i = 0;i < r_refdef.scene.numentities;i++)
8152         {
8153                 if (!r_refdef.viewcache.entityvisible[i])
8154                         continue;
8155                 ent = r_refdef.scene.entities[i];
8156                 if (ent->model && ent->model->DrawAddWaterPlanes != NULL)
8157                         ent->model->DrawAddWaterPlanes(ent);
8158         }
8159 }
8160
8161 static void R_View_SetFrustum(const int *scissor)
8162 {
8163         int i;
8164         double fpx = +1, fnx = -1, fpy = +1, fny = -1;
8165         vec3_t forward, left, up, origin, v;
8166
8167         if(scissor)
8168         {
8169                 // flipped x coordinates (because x points left here)
8170                 fpx =  1.0 - 2.0 * (scissor[0]              - r_refdef.view.viewport.x) / (double) (r_refdef.view.viewport.width);
8171                 fnx =  1.0 - 2.0 * (scissor[0] + scissor[2] - r_refdef.view.viewport.x) / (double) (r_refdef.view.viewport.width);
8172
8173                 // D3D Y coordinate is top to bottom, OpenGL is bottom to top, fix the D3D one
8174                 switch(vid.renderpath)
8175                 {
8176                         case RENDERPATH_D3D9:
8177                         case RENDERPATH_D3D10:
8178                         case RENDERPATH_D3D11:
8179                                 // non-flipped y coordinates
8180                                 fny = -1.0 + 2.0 * (vid.height - scissor[1] - scissor[3] - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
8181                                 fpy = -1.0 + 2.0 * (vid.height - scissor[1]              - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
8182                                 break;
8183                         case RENDERPATH_GL11:
8184                         case RENDERPATH_GL13:
8185                         case RENDERPATH_GL20:
8186                         case RENDERPATH_CGGL:
8187                                 // non-flipped y coordinates
8188                                 fny = -1.0 + 2.0 * (scissor[1]              - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
8189                                 fpy = -1.0 + 2.0 * (scissor[1] + scissor[3] - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
8190                                 break;
8191                 }
8192         }
8193
8194         // we can't trust r_refdef.view.forward and friends in reflected scenes
8195         Matrix4x4_ToVectors(&r_refdef.view.matrix, forward, left, up, origin);
8196
8197 #if 0
8198         r_refdef.view.frustum[0].normal[0] = 0 - 1.0 / r_refdef.view.frustum_x;
8199         r_refdef.view.frustum[0].normal[1] = 0 - 0;
8200         r_refdef.view.frustum[0].normal[2] = -1 - 0;
8201         r_refdef.view.frustum[1].normal[0] = 0 + 1.0 / r_refdef.view.frustum_x;
8202         r_refdef.view.frustum[1].normal[1] = 0 + 0;
8203         r_refdef.view.frustum[1].normal[2] = -1 + 0;
8204         r_refdef.view.frustum[2].normal[0] = 0 - 0;
8205         r_refdef.view.frustum[2].normal[1] = 0 - 1.0 / r_refdef.view.frustum_y;
8206         r_refdef.view.frustum[2].normal[2] = -1 - 0;
8207         r_refdef.view.frustum[3].normal[0] = 0 + 0;
8208         r_refdef.view.frustum[3].normal[1] = 0 + 1.0 / r_refdef.view.frustum_y;
8209         r_refdef.view.frustum[3].normal[2] = -1 + 0;
8210 #endif
8211
8212 #if 0
8213         zNear = r_refdef.nearclip;
8214         nudge = 1.0 - 1.0 / (1<<23);
8215         r_refdef.view.frustum[4].normal[0] = 0 - 0;
8216         r_refdef.view.frustum[4].normal[1] = 0 - 0;
8217         r_refdef.view.frustum[4].normal[2] = -1 - -nudge;
8218         r_refdef.view.frustum[4].dist = 0 - -2 * zNear * nudge;
8219         r_refdef.view.frustum[5].normal[0] = 0 + 0;
8220         r_refdef.view.frustum[5].normal[1] = 0 + 0;
8221         r_refdef.view.frustum[5].normal[2] = -1 + -nudge;
8222         r_refdef.view.frustum[5].dist = 0 + -2 * zNear * nudge;
8223 #endif
8224
8225
8226
8227 #if 0
8228         r_refdef.view.frustum[0].normal[0] = m[3] - m[0];
8229         r_refdef.view.frustum[0].normal[1] = m[7] - m[4];
8230         r_refdef.view.frustum[0].normal[2] = m[11] - m[8];
8231         r_refdef.view.frustum[0].dist = m[15] - m[12];
8232
8233         r_refdef.view.frustum[1].normal[0] = m[3] + m[0];
8234         r_refdef.view.frustum[1].normal[1] = m[7] + m[4];
8235         r_refdef.view.frustum[1].normal[2] = m[11] + m[8];
8236         r_refdef.view.frustum[1].dist = m[15] + m[12];
8237
8238         r_refdef.view.frustum[2].normal[0] = m[3] - m[1];
8239         r_refdef.view.frustum[2].normal[1] = m[7] - m[5];
8240         r_refdef.view.frustum[2].normal[2] = m[11] - m[9];
8241         r_refdef.view.frustum[2].dist = m[15] - m[13];
8242
8243         r_refdef.view.frustum[3].normal[0] = m[3] + m[1];
8244         r_refdef.view.frustum[3].normal[1] = m[7] + m[5];
8245         r_refdef.view.frustum[3].normal[2] = m[11] + m[9];
8246         r_refdef.view.frustum[3].dist = m[15] + m[13];
8247
8248         r_refdef.view.frustum[4].normal[0] = m[3] - m[2];
8249         r_refdef.view.frustum[4].normal[1] = m[7] - m[6];
8250         r_refdef.view.frustum[4].normal[2] = m[11] - m[10];
8251         r_refdef.view.frustum[4].dist = m[15] - m[14];
8252
8253         r_refdef.view.frustum[5].normal[0] = m[3] + m[2];
8254         r_refdef.view.frustum[5].normal[1] = m[7] + m[6];
8255         r_refdef.view.frustum[5].normal[2] = m[11] + m[10];
8256         r_refdef.view.frustum[5].dist = m[15] + m[14];
8257 #endif
8258
8259         if (r_refdef.view.useperspective)
8260         {
8261                 // calculate frustum corners, which are used to calculate deformed frustum planes for shadow caster culling
8262                 VectorMAMAM(1024, forward, fnx * 1024.0 * r_refdef.view.frustum_x, left, fny * 1024.0 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[0]);
8263                 VectorMAMAM(1024, forward, fpx * 1024.0 * r_refdef.view.frustum_x, left, fny * 1024.0 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[1]);
8264                 VectorMAMAM(1024, forward, fnx * 1024.0 * r_refdef.view.frustum_x, left, fpy * 1024.0 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[2]);
8265                 VectorMAMAM(1024, forward, fpx * 1024.0 * r_refdef.view.frustum_x, left, fpy * 1024.0 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[3]);
8266
8267                 // then the normals from the corners relative to origin
8268                 CrossProduct(r_refdef.view.frustumcorner[2], r_refdef.view.frustumcorner[0], r_refdef.view.frustum[0].normal);
8269                 CrossProduct(r_refdef.view.frustumcorner[1], r_refdef.view.frustumcorner[3], r_refdef.view.frustum[1].normal);
8270                 CrossProduct(r_refdef.view.frustumcorner[0], r_refdef.view.frustumcorner[1], r_refdef.view.frustum[2].normal);
8271                 CrossProduct(r_refdef.view.frustumcorner[3], r_refdef.view.frustumcorner[2], r_refdef.view.frustum[3].normal);
8272
8273                 // in a NORMAL view, forward cross left == up
8274                 // in a REFLECTED view, forward cross left == down
8275                 // so our cross products above need to be adjusted for a left handed coordinate system
8276                 CrossProduct(forward, left, v);
8277                 if(DotProduct(v, up) < 0)
8278                 {
8279                         VectorNegate(r_refdef.view.frustum[0].normal, r_refdef.view.frustum[0].normal);
8280                         VectorNegate(r_refdef.view.frustum[1].normal, r_refdef.view.frustum[1].normal);
8281                         VectorNegate(r_refdef.view.frustum[2].normal, r_refdef.view.frustum[2].normal);
8282                         VectorNegate(r_refdef.view.frustum[3].normal, r_refdef.view.frustum[3].normal);
8283                 }
8284
8285                 // Leaving those out was a mistake, those were in the old code, and they
8286                 // fix a reproducable bug in this one: frustum culling got fucked up when viewmatrix was an identity matrix
8287                 // I couldn't reproduce it after adding those normalizations. --blub
8288                 VectorNormalize(r_refdef.view.frustum[0].normal);
8289                 VectorNormalize(r_refdef.view.frustum[1].normal);
8290                 VectorNormalize(r_refdef.view.frustum[2].normal);
8291                 VectorNormalize(r_refdef.view.frustum[3].normal);
8292
8293                 // make the corners absolute
8294                 VectorAdd(r_refdef.view.frustumcorner[0], r_refdef.view.origin, r_refdef.view.frustumcorner[0]);
8295                 VectorAdd(r_refdef.view.frustumcorner[1], r_refdef.view.origin, r_refdef.view.frustumcorner[1]);
8296                 VectorAdd(r_refdef.view.frustumcorner[2], r_refdef.view.origin, r_refdef.view.frustumcorner[2]);
8297                 VectorAdd(r_refdef.view.frustumcorner[3], r_refdef.view.origin, r_refdef.view.frustumcorner[3]);
8298
8299                 // one more normal
8300                 VectorCopy(forward, r_refdef.view.frustum[4].normal);
8301
8302                 r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[0].normal);
8303                 r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[1].normal);
8304                 r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[2].normal);
8305                 r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[3].normal);
8306                 r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[4].normal) + r_refdef.nearclip;
8307         }
8308         else
8309         {
8310                 VectorScale(left, -r_refdef.view.ortho_x, r_refdef.view.frustum[0].normal);
8311                 VectorScale(left,  r_refdef.view.ortho_x, r_refdef.view.frustum[1].normal);
8312                 VectorScale(up, -r_refdef.view.ortho_y, r_refdef.view.frustum[2].normal);
8313                 VectorScale(up,  r_refdef.view.ortho_y, r_refdef.view.frustum[3].normal);
8314                 VectorCopy(forward, r_refdef.view.frustum[4].normal);
8315                 r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[0].normal) + r_refdef.view.ortho_x;
8316                 r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[1].normal) + r_refdef.view.ortho_x;
8317                 r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[2].normal) + r_refdef.view.ortho_y;
8318                 r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[3].normal) + r_refdef.view.ortho_y;
8319                 r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[4].normal) + r_refdef.nearclip;
8320         }
8321         r_refdef.view.numfrustumplanes = 5;
8322
8323         if (r_refdef.view.useclipplane)
8324         {
8325                 r_refdef.view.numfrustumplanes = 6;
8326                 r_refdef.view.frustum[5] = r_refdef.view.clipplane;
8327         }
8328
8329         for (i = 0;i < r_refdef.view.numfrustumplanes;i++)
8330                 PlaneClassify(r_refdef.view.frustum + i);
8331
8332         // LordHavoc: note to all quake engine coders, Quake had a special case
8333         // for 90 degrees which assumed a square view (wrong), so I removed it,
8334         // Quake2 has it disabled as well.
8335
8336         // rotate R_VIEWFORWARD right by FOV_X/2 degrees
8337         //RotatePointAroundVector( r_refdef.view.frustum[0].normal, up, forward, -(90 - r_refdef.fov_x / 2));
8338         //r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, frustum[0].normal);
8339         //PlaneClassify(&frustum[0]);
8340
8341         // rotate R_VIEWFORWARD left by FOV_X/2 degrees
8342         //RotatePointAroundVector( r_refdef.view.frustum[1].normal, up, forward, (90 - r_refdef.fov_x / 2));
8343         //r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, frustum[1].normal);
8344         //PlaneClassify(&frustum[1]);
8345
8346         // rotate R_VIEWFORWARD up by FOV_X/2 degrees
8347         //RotatePointAroundVector( r_refdef.view.frustum[2].normal, left, forward, -(90 - r_refdef.fov_y / 2));
8348         //r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, frustum[2].normal);
8349         //PlaneClassify(&frustum[2]);
8350
8351         // rotate R_VIEWFORWARD down by FOV_X/2 degrees
8352         //RotatePointAroundVector( r_refdef.view.frustum[3].normal, left, forward, (90 - r_refdef.fov_y / 2));
8353         //r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, frustum[3].normal);
8354         //PlaneClassify(&frustum[3]);
8355
8356         // nearclip plane
8357         //VectorCopy(forward, r_refdef.view.frustum[4].normal);
8358         //r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, frustum[4].normal) + r_nearclip.value;
8359         //PlaneClassify(&frustum[4]);
8360 }
8361
8362 void R_View_UpdateWithScissor(const int *myscissor)
8363 {
8364         R_Main_ResizeViewCache();
8365         R_View_SetFrustum(myscissor);
8366         R_View_WorldVisibility(r_refdef.view.useclipplane);
8367         R_View_UpdateEntityVisible();
8368         R_View_UpdateEntityLighting();
8369 }
8370
8371 void R_View_Update(void)
8372 {
8373         R_Main_ResizeViewCache();
8374         R_View_SetFrustum(NULL);
8375         R_View_WorldVisibility(r_refdef.view.useclipplane);
8376         R_View_UpdateEntityVisible();
8377         R_View_UpdateEntityLighting();
8378 }
8379
8380 void R_SetupView(qboolean allowwaterclippingplane)
8381 {
8382         const float *customclipplane = NULL;
8383         float plane[4];
8384         if (r_refdef.view.useclipplane && allowwaterclippingplane)
8385         {
8386                 // LordHavoc: couldn't figure out how to make this approach the
8387                 vec_t dist = r_refdef.view.clipplane.dist - r_water_clippingplanebias.value;
8388                 vec_t viewdist = DotProduct(r_refdef.view.origin, r_refdef.view.clipplane.normal);
8389                 if (viewdist < r_refdef.view.clipplane.dist + r_water_clippingplanebias.value)
8390                         dist = r_refdef.view.clipplane.dist;
8391                 plane[0] = r_refdef.view.clipplane.normal[0];
8392                 plane[1] = r_refdef.view.clipplane.normal[1];
8393                 plane[2] = r_refdef.view.clipplane.normal[2];
8394                 plane[3] = dist;
8395                 customclipplane = plane;
8396         }
8397
8398         if (!r_refdef.view.useperspective)
8399                 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);
8400         else if (vid.stencil && r_useinfinitefarclip.integer)
8401                 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);
8402         else
8403                 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);
8404         R_SetViewport(&r_refdef.view.viewport);
8405 }
8406
8407 void R_EntityMatrix(const matrix4x4_t *matrix)
8408 {
8409         if (gl_modelmatrixchanged || memcmp(matrix, &gl_modelmatrix, sizeof(matrix4x4_t)))
8410         {
8411                 gl_modelmatrixchanged = false;
8412                 gl_modelmatrix = *matrix;
8413                 Matrix4x4_Concat(&gl_modelviewmatrix, &gl_viewmatrix, &gl_modelmatrix);
8414                 Matrix4x4_Concat(&gl_modelviewprojectionmatrix, &gl_projectionmatrix, &gl_modelviewmatrix);
8415                 Matrix4x4_ToArrayFloatGL(&gl_modelviewmatrix, gl_modelview16f);
8416                 Matrix4x4_ToArrayFloatGL(&gl_modelviewprojectionmatrix, gl_modelviewprojection16f);
8417                 CHECKGLERROR
8418                 switch(vid.renderpath)
8419                 {
8420                 case RENDERPATH_D3D9:
8421 #ifdef SUPPORTD3D
8422                         hlslVSSetParameter16f(D3DVSREGISTER_ModelViewProjectionMatrix, gl_modelviewprojection16f);
8423                         hlslVSSetParameter16f(D3DVSREGISTER_ModelViewMatrix, gl_modelview16f);
8424 #endif
8425                         break;
8426                 case RENDERPATH_D3D10:
8427                         Con_DPrintf("FIXME D3D10 shader %s:%i\n", __FILE__, __LINE__);
8428                         break;
8429                 case RENDERPATH_D3D11:
8430                         Con_DPrintf("FIXME D3D11 shader %s:%i\n", __FILE__, __LINE__);
8431                         break;
8432                 case RENDERPATH_GL20:
8433                         if (r_glsl_permutation && r_glsl_permutation->loc_ModelViewProjectionMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewProjectionMatrix, 1, false, gl_modelviewprojection16f);
8434                         if (r_glsl_permutation && r_glsl_permutation->loc_ModelViewMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewMatrix, 1, false, gl_modelview16f);
8435                         qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
8436                         break;
8437                 case RENDERPATH_CGGL:
8438 #ifdef SUPPORTCG
8439                         CHECKCGERROR
8440                         if (r_cg_permutation && r_cg_permutation->vp_ModelViewProjectionMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewProjectionMatrix, gl_modelviewprojection16f);CHECKCGERROR
8441                         if (r_cg_permutation && r_cg_permutation->vp_ModelViewMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewMatrix, gl_modelview16f);CHECKCGERROR
8442                         qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
8443 #endif
8444                         break;
8445                 case RENDERPATH_GL13:
8446                 case RENDERPATH_GL11:
8447                         qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
8448                         break;
8449                 }
8450         }
8451 }
8452
8453 void R_ResetViewRendering2D(void)
8454 {
8455         r_viewport_t viewport;
8456         DrawQ_Finish();
8457
8458         // GL is weird because it's bottom to top, r_refdef.view.y is top to bottom
8459         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);
8460         R_SetViewport(&viewport);
8461         GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
8462         GL_Color(1, 1, 1, 1);
8463         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
8464         GL_BlendFunc(GL_ONE, GL_ZERO);
8465         GL_AlphaTest(false);
8466         GL_ScissorTest(false);
8467         GL_DepthMask(false);
8468         GL_DepthRange(0, 1);
8469         GL_DepthTest(false);
8470         GL_DepthFunc(GL_LEQUAL);
8471         R_EntityMatrix(&identitymatrix);
8472         R_Mesh_ResetTextureState();
8473         GL_PolygonOffset(0, 0);
8474         R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255);
8475         switch(vid.renderpath)
8476         {
8477         case RENDERPATH_GL11:
8478         case RENDERPATH_GL13:
8479         case RENDERPATH_GL20:
8480         case RENDERPATH_CGGL:
8481                 qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
8482                 break;
8483         case RENDERPATH_D3D9:
8484         case RENDERPATH_D3D10:
8485         case RENDERPATH_D3D11:
8486                 break;
8487         }
8488         GL_CullFace(GL_NONE);
8489 }
8490
8491 void R_ResetViewRendering3D(void)
8492 {
8493         DrawQ_Finish();
8494
8495         R_SetupView(true);
8496         GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
8497         GL_Color(1, 1, 1, 1);
8498         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
8499         GL_BlendFunc(GL_ONE, GL_ZERO);
8500         GL_AlphaTest(false);
8501         GL_ScissorTest(true);
8502         GL_DepthMask(true);
8503         GL_DepthRange(0, 1);
8504         GL_DepthTest(true);
8505         GL_DepthFunc(GL_LEQUAL);
8506         R_EntityMatrix(&identitymatrix);
8507         R_Mesh_ResetTextureState();
8508         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
8509         R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255);
8510         switch(vid.renderpath)
8511         {
8512         case RENDERPATH_GL11:
8513         case RENDERPATH_GL13:
8514         case RENDERPATH_GL20:
8515         case RENDERPATH_CGGL:
8516                 qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
8517                 break;
8518         case RENDERPATH_D3D9:
8519         case RENDERPATH_D3D10:
8520         case RENDERPATH_D3D11:
8521                 break;
8522         }
8523         GL_CullFace(r_refdef.view.cullface_back);
8524 }
8525
8526 /*
8527 ================
8528 R_RenderView_UpdateViewVectors
8529 ================
8530 */
8531 static void R_RenderView_UpdateViewVectors(void)
8532 {
8533         // break apart the view matrix into vectors for various purposes
8534         // it is important that this occurs outside the RenderScene function because that can be called from reflection renders, where the vectors come out wrong
8535         // however the r_refdef.view.origin IS updated in RenderScene intentionally - otherwise the sky renders at the wrong origin, etc
8536         Matrix4x4_ToVectors(&r_refdef.view.matrix, r_refdef.view.forward, r_refdef.view.left, r_refdef.view.up, r_refdef.view.origin);
8537         VectorNegate(r_refdef.view.left, r_refdef.view.right);
8538         // make an inverted copy of the view matrix for tracking sprites
8539         Matrix4x4_Invert_Simple(&r_refdef.view.inverse_matrix, &r_refdef.view.matrix);
8540 }
8541
8542 void R_RenderScene(void);
8543 void R_RenderWaterPlanes(void);
8544
8545 static void R_Water_StartFrame(void)
8546 {
8547         int i;
8548         int waterwidth, waterheight, texturewidth, textureheight, camerawidth, cameraheight;
8549         r_waterstate_waterplane_t *p;
8550
8551         if (vid.width > (int)vid.maxtexturesize_2d || vid.height > (int)vid.maxtexturesize_2d)
8552                 return;
8553
8554         switch(vid.renderpath)
8555         {
8556         case RENDERPATH_GL20:
8557         case RENDERPATH_CGGL:
8558         case RENDERPATH_D3D9:
8559         case RENDERPATH_D3D10:
8560         case RENDERPATH_D3D11:
8561                 break;
8562         case RENDERPATH_GL13:
8563         case RENDERPATH_GL11:
8564                 return;
8565         }
8566
8567         // set waterwidth and waterheight to the water resolution that will be
8568         // used (often less than the screen resolution for faster rendering)
8569         waterwidth = (int)bound(1, vid.width * r_water_resolutionmultiplier.value, vid.width);
8570         waterheight = (int)bound(1, vid.height * r_water_resolutionmultiplier.value, vid.height);
8571
8572         // calculate desired texture sizes
8573         // can't use water if the card does not support the texture size
8574         if (!r_water.integer || r_showsurfaces.integer)
8575                 texturewidth = textureheight = waterwidth = waterheight = camerawidth = cameraheight = 0;
8576         else if (vid.support.arb_texture_non_power_of_two)
8577         {
8578                 texturewidth = waterwidth;
8579                 textureheight = waterheight;
8580                 camerawidth = waterwidth;
8581                 cameraheight = waterheight;
8582         }
8583         else
8584         {
8585                 for (texturewidth   = 1;texturewidth   < waterwidth ;texturewidth   *= 2);
8586                 for (textureheight  = 1;textureheight  < waterheight;textureheight  *= 2);
8587                 for (camerawidth    = 1;camerawidth   <= waterwidth; camerawidth    *= 2); camerawidth  /= 2;
8588                 for (cameraheight   = 1;cameraheight  <= waterheight;cameraheight   *= 2); cameraheight /= 2;
8589         }
8590
8591         // allocate textures as needed
8592         if (r_waterstate.texturewidth != texturewidth || r_waterstate.textureheight != textureheight || r_waterstate.camerawidth != camerawidth || r_waterstate.cameraheight != cameraheight)
8593         {
8594                 r_waterstate.maxwaterplanes = MAX_WATERPLANES;
8595                 for (i = 0, p = r_waterstate.waterplanes;i < r_waterstate.maxwaterplanes;i++, p++)
8596                 {
8597                         if (p->texture_refraction)
8598                                 R_FreeTexture(p->texture_refraction);
8599                         p->texture_refraction = NULL;
8600                         if (p->texture_reflection)
8601                                 R_FreeTexture(p->texture_reflection);
8602                         p->texture_reflection = NULL;
8603                         if (p->texture_camera)
8604                                 R_FreeTexture(p->texture_camera);
8605                         p->texture_camera = NULL;
8606                 }
8607                 memset(&r_waterstate, 0, sizeof(r_waterstate));
8608                 r_waterstate.texturewidth = texturewidth;
8609                 r_waterstate.textureheight = textureheight;
8610                 r_waterstate.camerawidth = camerawidth;
8611                 r_waterstate.cameraheight = cameraheight;
8612         }
8613
8614         if (r_waterstate.texturewidth)
8615         {
8616                 r_waterstate.enabled = true;
8617
8618                 // when doing a reduced render (HDR) we want to use a smaller area
8619                 r_waterstate.waterwidth = (int)bound(1, r_refdef.view.width * r_water_resolutionmultiplier.value, r_refdef.view.width);
8620                 r_waterstate.waterheight = (int)bound(1, r_refdef.view.height * r_water_resolutionmultiplier.value, r_refdef.view.height);
8621
8622                 // set up variables that will be used in shader setup
8623                 r_waterstate.screenscale[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
8624                 r_waterstate.screenscale[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
8625                 r_waterstate.screencenter[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
8626                 r_waterstate.screencenter[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
8627         }
8628
8629         r_waterstate.maxwaterplanes = MAX_WATERPLANES;
8630         r_waterstate.numwaterplanes = 0;
8631 }
8632
8633 void R_Water_AddWaterPlane(msurface_t *surface, int entno)
8634 {
8635         int triangleindex, planeindex;
8636         const int *e;
8637         vec3_t vert[3];
8638         vec3_t normal;
8639         vec3_t center;
8640         mplane_t plane;
8641         r_waterstate_waterplane_t *p;
8642         texture_t *t = R_GetCurrentTexture(surface->texture);
8643
8644         // just use the first triangle with a valid normal for any decisions
8645         VectorClear(normal);
8646         for (triangleindex = 0, e = rsurface.modelelement3i + surface->num_firsttriangle * 3;triangleindex < surface->num_triangles;triangleindex++, e += 3)
8647         {
8648                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[0]*3, vert[0]);
8649                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[1]*3, vert[1]);
8650                 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[2]*3, vert[2]);
8651                 TriangleNormal(vert[0], vert[1], vert[2], normal);
8652                 if (VectorLength2(normal) >= 0.001)
8653                         break;
8654         }
8655
8656         VectorCopy(normal, plane.normal);
8657         VectorNormalize(plane.normal);
8658         plane.dist = DotProduct(vert[0], plane.normal);
8659         PlaneClassify(&plane);
8660         if (PlaneDiff(r_refdef.view.origin, &plane) < 0)
8661         {
8662                 // skip backfaces (except if nocullface is set)
8663                 if (!(t->currentmaterialflags & MATERIALFLAG_NOCULLFACE))
8664                         return;
8665                 VectorNegate(plane.normal, plane.normal);
8666                 plane.dist *= -1;
8667                 PlaneClassify(&plane);
8668         }
8669
8670
8671         // find a matching plane if there is one
8672         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
8673                 if(p->camera_entity == t->camera_entity)
8674                         if (fabs(PlaneDiff(vert[0], &p->plane)) < 1 && fabs(PlaneDiff(vert[1], &p->plane)) < 1 && fabs(PlaneDiff(vert[2], &p->plane)) < 1)
8675                                 break;
8676         if (planeindex >= r_waterstate.maxwaterplanes)
8677                 return; // nothing we can do, out of planes
8678
8679         // if this triangle does not fit any known plane rendered this frame, add one
8680         if (planeindex >= r_waterstate.numwaterplanes)
8681         {
8682                 // store the new plane
8683                 r_waterstate.numwaterplanes++;
8684                 p->plane = plane;
8685                 // clear materialflags and pvs
8686                 p->materialflags = 0;
8687                 p->pvsvalid = false;
8688                 p->camera_entity = t->camera_entity;
8689                 VectorCopy(surface->mins, p->mins);
8690                 VectorCopy(surface->maxs, p->maxs);
8691         }
8692         else
8693         {
8694                 // merge mins/maxs
8695                 p->mins[0] = min(p->mins[0], surface->mins[0]);
8696                 p->mins[1] = min(p->mins[1], surface->mins[1]);
8697                 p->mins[2] = min(p->mins[2], surface->mins[2]);
8698                 p->maxs[0] = max(p->maxs[0], surface->maxs[0]);
8699                 p->maxs[1] = max(p->maxs[1], surface->maxs[1]);
8700                 p->maxs[2] = max(p->maxs[2], surface->maxs[2]);
8701         }
8702         // merge this surface's materialflags into the waterplane
8703         p->materialflags |= t->currentmaterialflags;
8704         if(!(p->materialflags & MATERIALFLAG_CAMERA))
8705         {
8706                 // merge this surface's PVS into the waterplane
8707                 VectorMAM(0.5f, surface->mins, 0.5f, surface->maxs, center);
8708                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS
8709                  && r_refdef.scene.worldmodel->brush.PointInLeaf && r_refdef.scene.worldmodel->brush.PointInLeaf(r_refdef.scene.worldmodel, center)->clusterindex >= 0)
8710                 {
8711                         r_refdef.scene.worldmodel->brush.FatPVS(r_refdef.scene.worldmodel, center, 2, p->pvsbits, sizeof(p->pvsbits), p->pvsvalid);
8712                         p->pvsvalid = true;
8713                 }
8714         }
8715 }
8716
8717 static void R_Water_ProcessPlanes(void)
8718 {
8719         int myscissor[4];
8720         r_refdef_view_t originalview;
8721         r_refdef_view_t myview;
8722         int planeindex;
8723         r_waterstate_waterplane_t *p;
8724         vec3_t visorigin;
8725
8726         originalview = r_refdef.view;
8727
8728         // make sure enough textures are allocated
8729         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
8730         {
8731                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
8732                 {
8733                         if (!p->texture_refraction)
8734                                 p->texture_refraction = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_refraction", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
8735                         if (!p->texture_refraction)
8736                                 goto error;
8737                 }
8738                 else if (p->materialflags & MATERIALFLAG_CAMERA)
8739                 {
8740                         if (!p->texture_camera)
8741                                 p->texture_camera = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_camera", planeindex), r_waterstate.camerawidth, r_waterstate.cameraheight, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_FORCELINEAR, -1, NULL);
8742                         if (!p->texture_camera)
8743                                 goto error;
8744                 }
8745
8746                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
8747                 {
8748                         if (!p->texture_reflection)
8749                                 p->texture_reflection = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_reflection", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
8750                         if (!p->texture_reflection)
8751                                 goto error;
8752                 }
8753         }
8754
8755         // render views
8756         r_refdef.view = originalview;
8757         r_refdef.view.showdebug = false;
8758         r_refdef.view.width = r_waterstate.waterwidth;
8759         r_refdef.view.height = r_waterstate.waterheight;
8760         r_refdef.view.useclipplane = true;
8761         myview = r_refdef.view;
8762         r_waterstate.renderingscene = true;
8763         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
8764         {
8765                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
8766                 {
8767                         r_refdef.view = myview;
8768                         if(r_water_scissormode.integer)
8769                         {
8770                                 R_SetupView(true);
8771                                 if(R_ScissorForBBox(p->mins, p->maxs, myscissor))
8772                                         continue; // FIXME the plane then still may get rendered but with broken texture, but it sure won't be visible
8773                         }
8774
8775                         // render reflected scene and copy into texture
8776                         Matrix4x4_Reflect(&r_refdef.view.matrix, p->plane.normal[0], p->plane.normal[1], p->plane.normal[2], p->plane.dist, -2);
8777                         // update the r_refdef.view.origin because otherwise the sky renders at the wrong location (amongst other problems)
8778                         Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, r_refdef.view.origin);
8779                         r_refdef.view.clipplane = p->plane;
8780
8781                         // reverse the cullface settings for this render
8782                         r_refdef.view.cullface_front = GL_FRONT;
8783                         r_refdef.view.cullface_back = GL_BACK;
8784                         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.num_pvsclusterbytes)
8785                         {
8786                                 r_refdef.view.usecustompvs = true;
8787                                 if (p->pvsvalid)
8788                                         memcpy(r_refdef.viewcache.world_pvsbits, p->pvsbits, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
8789                                 else
8790                                         memset(r_refdef.viewcache.world_pvsbits, 0xFF, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
8791                         }
8792
8793                         R_ResetViewRendering3D();
8794                         R_ClearScreen(r_refdef.fogenabled);
8795                         if(r_water_scissormode.integer & 2)
8796                                 R_View_UpdateWithScissor(myscissor);
8797                         else
8798                                 R_View_Update();
8799                         if(r_water_scissormode.integer & 1)
8800                                 GL_Scissor(myscissor[0], myscissor[1], myscissor[2], myscissor[3]);
8801                         R_RenderScene();
8802
8803                         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);
8804                 }
8805
8806                 // render the normal view scene and copy into texture
8807                 // (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)
8808                 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
8809                 {
8810                         r_refdef.view = myview;
8811                         if(r_water_scissormode.integer)
8812                         {
8813                                 R_SetupView(true);
8814                                 if(R_ScissorForBBox(p->mins, p->maxs, myscissor))
8815                                         continue; // FIXME the plane then still may get rendered but with broken texture, but it sure won't be visible
8816                         }
8817
8818                         r_waterstate.renderingrefraction = true;
8819
8820                         r_refdef.view.clipplane = p->plane;
8821                         VectorNegate(r_refdef.view.clipplane.normal, r_refdef.view.clipplane.normal);
8822                         r_refdef.view.clipplane.dist = -r_refdef.view.clipplane.dist;
8823
8824                         if((p->materialflags & MATERIALFLAG_CAMERA) && p->camera_entity)
8825                         {
8826                                 // we need to perform a matrix transform to render the view... so let's get the transformation matrix
8827                                 r_waterstate.renderingrefraction = false; // we don't want to hide the player model from these ones
8828                                 CL_VM_TransformView(p->camera_entity - MAX_EDICTS, &r_refdef.view.matrix, &r_refdef.view.clipplane, visorigin);
8829                                 R_RenderView_UpdateViewVectors();
8830                                 if(r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS)
8831                                 {
8832                                         r_refdef.view.usecustompvs = true;
8833                                         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);
8834                                 }
8835                         }
8836
8837                         PlaneClassify(&r_refdef.view.clipplane);
8838
8839                         R_ResetViewRendering3D();
8840                         R_ClearScreen(r_refdef.fogenabled);
8841                         if(r_water_scissormode.integer & 2)
8842                                 R_View_UpdateWithScissor(myscissor);
8843                         else
8844                                 R_View_Update();
8845                         if(r_water_scissormode.integer & 1)
8846                                 GL_Scissor(myscissor[0], myscissor[1], myscissor[2], myscissor[3]);
8847                         R_RenderScene();
8848
8849                         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);
8850                         r_waterstate.renderingrefraction = false;
8851                 }
8852                 else if (p->materialflags & MATERIALFLAG_CAMERA)
8853                 {
8854                         r_refdef.view = myview;
8855
8856                         r_refdef.view.clipplane = p->plane;
8857                         VectorNegate(r_refdef.view.clipplane.normal, r_refdef.view.clipplane.normal);
8858                         r_refdef.view.clipplane.dist = -r_refdef.view.clipplane.dist;
8859
8860                         r_refdef.view.width = r_waterstate.camerawidth;
8861                         r_refdef.view.height = r_waterstate.cameraheight;
8862                         r_refdef.view.frustum_x = 1; // tan(45 * M_PI / 180.0);
8863                         r_refdef.view.frustum_y = 1; // tan(45 * M_PI / 180.0);
8864
8865                         if(p->camera_entity)
8866                         {
8867                                 // we need to perform a matrix transform to render the view... so let's get the transformation matrix
8868                                 CL_VM_TransformView(p->camera_entity - MAX_EDICTS, &r_refdef.view.matrix, &r_refdef.view.clipplane, visorigin);
8869                         }
8870
8871                         // note: all of the view is used for displaying... so
8872                         // there is no use in scissoring
8873
8874                         // reverse the cullface settings for this render
8875                         r_refdef.view.cullface_front = GL_FRONT;
8876                         r_refdef.view.cullface_back = GL_BACK;
8877                         // also reverse the view matrix
8878                         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
8879                         R_RenderView_UpdateViewVectors();
8880                         if(p->camera_entity && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS)
8881                         {
8882                                 r_refdef.view.usecustompvs = true;
8883                                 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);
8884                         }
8885
8886                         // camera needs no clipplane
8887                         r_refdef.view.useclipplane = false;
8888
8889                         PlaneClassify(&r_refdef.view.clipplane);
8890
8891                         R_ResetViewRendering3D();
8892                         R_ClearScreen(r_refdef.fogenabled);
8893                         R_View_Update();
8894                         R_RenderScene();
8895
8896                         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);
8897                         r_waterstate.renderingrefraction = false;
8898                 }
8899
8900         }
8901         r_waterstate.renderingscene = false;
8902         r_refdef.view = originalview;
8903         R_ResetViewRendering3D();
8904         R_ClearScreen(r_refdef.fogenabled);
8905         R_View_Update();
8906         return;
8907 error:
8908         r_refdef.view = originalview;
8909         r_waterstate.renderingscene = false;
8910         Cvar_SetValueQuick(&r_water, 0);
8911         Con_Printf("R_Water_ProcessPlanes: Error: texture creation failed!  Turned off r_water.\n");
8912         return;
8913 }
8914
8915 void R_Bloom_StartFrame(void)
8916 {
8917         int bloomtexturewidth, bloomtextureheight, screentexturewidth, screentextureheight;
8918
8919         switch(vid.renderpath)
8920         {
8921         case RENDERPATH_GL20:
8922         case RENDERPATH_CGGL:
8923         case RENDERPATH_D3D9:
8924         case RENDERPATH_D3D10:
8925         case RENDERPATH_D3D11:
8926                 break;
8927         case RENDERPATH_GL13:
8928         case RENDERPATH_GL11:
8929                 return;
8930         }
8931
8932         // set bloomwidth and bloomheight to the bloom resolution that will be
8933         // used (often less than the screen resolution for faster rendering)
8934         r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, vid.height);
8935         r_bloomstate.bloomheight = r_bloomstate.bloomwidth * vid.height / vid.width;
8936         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, vid.height);
8937         r_bloomstate.bloomwidth = bound(1, r_bloomstate.bloomwidth, (int)vid.maxtexturesize_2d);
8938         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, (int)vid.maxtexturesize_2d);
8939
8940         // calculate desired texture sizes
8941         if (vid.support.arb_texture_non_power_of_two)
8942         {
8943                 screentexturewidth = r_refdef.view.width;
8944                 screentextureheight = r_refdef.view.height;
8945                 bloomtexturewidth = r_bloomstate.bloomwidth;
8946                 bloomtextureheight = r_bloomstate.bloomheight;
8947         }
8948         else
8949         {
8950                 for (screentexturewidth  = 1;screentexturewidth  < vid.width               ;screentexturewidth  *= 2);
8951                 for (screentextureheight = 1;screentextureheight < vid.height              ;screentextureheight *= 2);
8952                 for (bloomtexturewidth   = 1;bloomtexturewidth   < r_bloomstate.bloomwidth ;bloomtexturewidth   *= 2);
8953                 for (bloomtextureheight  = 1;bloomtextureheight  < r_bloomstate.bloomheight;bloomtextureheight  *= 2);
8954         }
8955
8956         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))
8957         {
8958                 Cvar_SetValueQuick(&r_hdr, 0);
8959                 Cvar_SetValueQuick(&r_bloom, 0);
8960                 Cvar_SetValueQuick(&r_motionblur, 0);
8961                 Cvar_SetValueQuick(&r_damageblur, 0);
8962         }
8963
8964         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)))
8965                 screentexturewidth = screentextureheight = 0;
8966         if (!r_hdr.integer && !r_bloom.integer)
8967                 bloomtexturewidth = bloomtextureheight = 0;
8968
8969         // allocate textures as needed
8970         if (r_bloomstate.screentexturewidth != screentexturewidth || r_bloomstate.screentextureheight != screentextureheight)
8971         {
8972                 if (r_bloomstate.texture_screen)
8973                         R_FreeTexture(r_bloomstate.texture_screen);
8974                 r_bloomstate.texture_screen = NULL;
8975                 r_bloomstate.screentexturewidth = screentexturewidth;
8976                 r_bloomstate.screentextureheight = screentextureheight;
8977                 if (r_bloomstate.screentexturewidth && r_bloomstate.screentextureheight)
8978                         r_bloomstate.texture_screen = R_LoadTexture2D(r_main_texturepool, "screen", r_bloomstate.screentexturewidth, r_bloomstate.screentextureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_FORCENEAREST | TEXF_CLAMP, -1, NULL);
8979         }
8980         if (r_bloomstate.bloomtexturewidth != bloomtexturewidth || r_bloomstate.bloomtextureheight != bloomtextureheight)
8981         {
8982                 if (r_bloomstate.texture_bloom)
8983                         R_FreeTexture(r_bloomstate.texture_bloom);
8984                 r_bloomstate.texture_bloom = NULL;
8985                 r_bloomstate.bloomtexturewidth = bloomtexturewidth;
8986                 r_bloomstate.bloomtextureheight = bloomtextureheight;
8987                 if (r_bloomstate.bloomtexturewidth && r_bloomstate.bloomtextureheight)
8988                         r_bloomstate.texture_bloom = R_LoadTexture2D(r_main_texturepool, "bloom", r_bloomstate.bloomtexturewidth, r_bloomstate.bloomtextureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
8989         }
8990
8991         // when doing a reduced render (HDR) we want to use a smaller area
8992         r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, r_refdef.view.height);
8993         r_bloomstate.bloomheight = r_bloomstate.bloomwidth * r_refdef.view.height / r_refdef.view.width;
8994         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_refdef.view.height);
8995         r_bloomstate.bloomwidth = bound(1, r_bloomstate.bloomwidth, r_bloomstate.bloomtexturewidth);
8996         r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_bloomstate.bloomtextureheight);
8997
8998         // set up a texcoord array for the full resolution screen image
8999         // (we have to keep this around to copy back during final render)
9000         r_bloomstate.screentexcoord2f[0] = 0;
9001         r_bloomstate.screentexcoord2f[1] = (float)r_refdef.view.height    / (float)r_bloomstate.screentextureheight;
9002         r_bloomstate.screentexcoord2f[2] = (float)r_refdef.view.width     / (float)r_bloomstate.screentexturewidth;
9003         r_bloomstate.screentexcoord2f[3] = (float)r_refdef.view.height    / (float)r_bloomstate.screentextureheight;
9004         r_bloomstate.screentexcoord2f[4] = (float)r_refdef.view.width     / (float)r_bloomstate.screentexturewidth;
9005         r_bloomstate.screentexcoord2f[5] = 0;
9006         r_bloomstate.screentexcoord2f[6] = 0;
9007         r_bloomstate.screentexcoord2f[7] = 0;
9008
9009         // set up a texcoord array for the reduced resolution bloom image
9010         // (which will be additive blended over the screen image)
9011         r_bloomstate.bloomtexcoord2f[0] = 0;
9012         r_bloomstate.bloomtexcoord2f[1] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
9013         r_bloomstate.bloomtexcoord2f[2] = (float)r_bloomstate.bloomwidth  / (float)r_bloomstate.bloomtexturewidth;
9014         r_bloomstate.bloomtexcoord2f[3] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
9015         r_bloomstate.bloomtexcoord2f[4] = (float)r_bloomstate.bloomwidth  / (float)r_bloomstate.bloomtexturewidth;
9016         r_bloomstate.bloomtexcoord2f[5] = 0;
9017         r_bloomstate.bloomtexcoord2f[6] = 0;
9018         r_bloomstate.bloomtexcoord2f[7] = 0;
9019
9020         switch(vid.renderpath)
9021         {
9022         case RENDERPATH_GL11:
9023         case RENDERPATH_GL13:
9024         case RENDERPATH_GL20:
9025         case RENDERPATH_CGGL:
9026                 break;
9027         case RENDERPATH_D3D9:
9028         case RENDERPATH_D3D10:
9029         case RENDERPATH_D3D11:
9030                 {
9031                         int i;
9032                         for (i = 0;i < 4;i++)
9033                         {
9034                                 r_bloomstate.screentexcoord2f[i*2+0] += 0.5f / (float)r_bloomstate.screentexturewidth;
9035                                 r_bloomstate.screentexcoord2f[i*2+1] += 0.5f / (float)r_bloomstate.screentextureheight;
9036                                 r_bloomstate.bloomtexcoord2f[i*2+0] += 0.5f / (float)r_bloomstate.bloomtexturewidth;
9037                                 r_bloomstate.bloomtexcoord2f[i*2+1] += 0.5f / (float)r_bloomstate.bloomtextureheight;
9038                         }
9039                 }
9040                 break;
9041         }
9042
9043         if (r_hdr.integer || r_bloom.integer)
9044         {
9045                 r_bloomstate.enabled = true;
9046                 r_bloomstate.hdr = r_hdr.integer != 0;
9047         }
9048
9049         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);
9050 }
9051
9052 void R_Bloom_CopyBloomTexture(float colorscale)
9053 {
9054         r_refdef.stats.bloom++;
9055
9056         // scale down screen texture to the bloom texture size
9057         CHECKGLERROR
9058         R_SetViewport(&r_bloomstate.viewport);
9059         GL_BlendFunc(GL_ONE, GL_ZERO);
9060         GL_Color(colorscale, colorscale, colorscale, 1);
9061         // D3D has upside down Y coords, the easiest way to flip this is to flip the screen vertices rather than the texcoords, so we just use a different array for that...
9062         switch(vid.renderpath)
9063         {
9064         case RENDERPATH_GL11:
9065         case RENDERPATH_GL13:
9066         case RENDERPATH_GL20:
9067         case RENDERPATH_CGGL:
9068                 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_bloomstate.screentexcoord2f);
9069                 break;
9070         case RENDERPATH_D3D9:
9071         case RENDERPATH_D3D10:
9072         case RENDERPATH_D3D11:
9073                 R_Mesh_PrepareVertices_Generic_Arrays(4, r_d3dscreenvertex3f, NULL, r_bloomstate.screentexcoord2f);
9074                 break;
9075         }
9076         // TODO: do boxfilter scale-down in shader?
9077         R_SetupShader_Generic(r_bloomstate.texture_screen, NULL, GL_MODULATE, 1);
9078         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
9079         r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
9080
9081         // we now have a bloom image in the framebuffer
9082         // copy it into the bloom image texture for later processing
9083         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);
9084         r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
9085 }
9086
9087 void R_Bloom_CopyHDRTexture(void)
9088 {
9089         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);
9090         r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
9091 }
9092
9093 void R_Bloom_MakeTexture(void)
9094 {
9095         int x, range, dir;
9096         float xoffset, yoffset, r, brighten;
9097
9098         r_refdef.stats.bloom++;
9099
9100         R_ResetViewRendering2D();
9101
9102         // we have a bloom image in the framebuffer
9103         CHECKGLERROR
9104         R_SetViewport(&r_bloomstate.viewport);
9105
9106         for (x = 1;x < min(r_bloom_colorexponent.value, 32);)
9107         {
9108                 x *= 2;
9109                 r = bound(0, r_bloom_colorexponent.value / x, 1);
9110                 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
9111                 GL_Color(r,r,r,1);
9112                 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_bloomstate.bloomtexcoord2f);
9113                 R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
9114                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
9115                 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
9116
9117                 // copy the vertically blurred bloom view to a texture
9118                 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);
9119                 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
9120         }
9121
9122         range = r_bloom_blur.integer * r_bloomstate.bloomwidth / 320;
9123         brighten = r_bloom_brighten.value;
9124         if (r_hdr.integer)
9125                 brighten *= r_hdr_range.value;
9126         brighten = sqrt(brighten);
9127         if(range >= 1)
9128                 brighten *= (3 * range) / (2 * range - 1); // compensate for the "dot particle"
9129         R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
9130
9131         for (dir = 0;dir < 2;dir++)
9132         {
9133                 // blend on at multiple vertical offsets to achieve a vertical blur
9134                 // TODO: do offset blends using GLSL
9135                 // TODO instead of changing the texcoords, change the target positions to prevent artifacts at edges
9136                 GL_BlendFunc(GL_ONE, GL_ZERO);
9137                 for (x = -range;x <= range;x++)
9138                 {
9139                         if (!dir){xoffset = 0;yoffset = x;}
9140                         else {xoffset = x;yoffset = 0;}
9141                         xoffset /= (float)r_bloomstate.bloomtexturewidth;
9142                         yoffset /= (float)r_bloomstate.bloomtextureheight;
9143                         // compute a texcoord array with the specified x and y offset
9144                         r_bloomstate.offsettexcoord2f[0] = xoffset+0;
9145                         r_bloomstate.offsettexcoord2f[1] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
9146                         r_bloomstate.offsettexcoord2f[2] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
9147                         r_bloomstate.offsettexcoord2f[3] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
9148                         r_bloomstate.offsettexcoord2f[4] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
9149                         r_bloomstate.offsettexcoord2f[5] = yoffset+0;
9150                         r_bloomstate.offsettexcoord2f[6] = xoffset+0;
9151                         r_bloomstate.offsettexcoord2f[7] = yoffset+0;
9152                         // this r value looks like a 'dot' particle, fading sharply to
9153                         // black at the edges
9154                         // (probably not realistic but looks good enough)
9155                         //r = ((range*range+1)/((float)(x*x+1)))/(range*2+1);
9156                         //r = brighten/(range*2+1);
9157                         r = brighten / (range * 2 + 1);
9158                         if(range >= 1)
9159                                 r *= (1 - x*x/(float)(range*range));
9160                         GL_Color(r, r, r, 1);
9161                         R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_bloomstate.offsettexcoord2f);
9162                         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
9163                         r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
9164                         GL_BlendFunc(GL_ONE, GL_ONE);
9165                 }
9166
9167                 // copy the vertically blurred bloom view to a texture
9168                 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);
9169                 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
9170         }
9171 }
9172
9173 void R_HDR_RenderBloomTexture(void)
9174 {
9175         int oldwidth, oldheight;
9176         float oldcolorscale;
9177         int oldwaterstate;
9178
9179         oldwaterstate = r_waterstate.enabled;
9180         oldcolorscale = r_refdef.view.colorscale;
9181         oldwidth = r_refdef.view.width;
9182         oldheight = r_refdef.view.height;
9183         r_refdef.view.width = r_bloomstate.bloomwidth;
9184         r_refdef.view.height = r_bloomstate.bloomheight;
9185
9186         if(r_hdr.integer < 2)
9187                 r_waterstate.enabled = false;
9188
9189         // TODO: support GL_EXT_framebuffer_object rather than reusing the framebuffer?  it might improve SLI performance.
9190         // TODO: add exposure compensation features
9191         // TODO: add fp16 framebuffer support (using GL_EXT_framebuffer_object)
9192
9193         r_refdef.view.showdebug = false;
9194         r_refdef.view.colorscale *= r_bloom_colorscale.value / bound(1, r_hdr_range.value, 16);
9195
9196         R_ResetViewRendering3D();
9197
9198         R_ClearScreen(r_refdef.fogenabled);
9199         if (r_timereport_active)
9200                 R_TimeReport("HDRclear");
9201
9202         R_View_Update();
9203         if (r_timereport_active)
9204                 R_TimeReport("visibility");
9205
9206         // only do secondary renders with HDR if r_hdr is 2 or higher
9207         r_waterstate.numwaterplanes = 0;
9208         if (r_waterstate.enabled)
9209                 R_RenderWaterPlanes();
9210
9211         r_refdef.view.showdebug = true;
9212         R_RenderScene();
9213         r_waterstate.numwaterplanes = 0;
9214
9215         R_ResetViewRendering2D();
9216
9217         R_Bloom_CopyHDRTexture();
9218         R_Bloom_MakeTexture();
9219
9220         // restore the view settings
9221         r_waterstate.enabled = oldwaterstate;
9222         r_refdef.view.width = oldwidth;
9223         r_refdef.view.height = oldheight;
9224         r_refdef.view.colorscale = oldcolorscale;
9225
9226         R_ResetViewRendering3D();
9227
9228         R_ClearScreen(r_refdef.fogenabled);
9229         if (r_timereport_active)
9230                 R_TimeReport("viewclear");
9231 }
9232
9233 static void R_BlendView(void)
9234 {
9235         unsigned int permutation;
9236         float uservecs[4][4];
9237
9238         switch (vid.renderpath)
9239         {
9240         case RENDERPATH_GL20:
9241         case RENDERPATH_CGGL:
9242         case RENDERPATH_D3D9:
9243         case RENDERPATH_D3D10:
9244         case RENDERPATH_D3D11:
9245                 permutation =
9246                           (r_bloomstate.texture_bloom ? SHADERPERMUTATION_BLOOM : 0)
9247                         | (r_refdef.viewblend[3] > 0 ? SHADERPERMUTATION_VIEWTINT : 0)
9248                         | ((v_glslgamma.value && !vid_gammatables_trivial) ? SHADERPERMUTATION_GAMMARAMPS : 0)
9249                         | (r_glsl_postprocess.integer ? SHADERPERMUTATION_POSTPROCESSING : 0)
9250                         | ((!R_Stereo_ColorMasking() && r_glsl_saturation.value != 1) ? SHADERPERMUTATION_SATURATION : 0);
9251
9252                 if (r_bloomstate.texture_screen)
9253                 {
9254                         // make sure the buffer is available
9255                         if (r_bloom_blur.value < 1) { Cvar_SetValueQuick(&r_bloom_blur, 1); }
9256
9257                         R_ResetViewRendering2D();
9258
9259                         if(!R_Stereo_Active() && (r_motionblur.value > 0 || r_damageblur.value > 0))
9260                         {
9261                                 // declare variables
9262                                 float speed;
9263                                 static float avgspeed;
9264
9265                                 speed = VectorLength(cl.movement_velocity);
9266
9267                                 cl.motionbluralpha = bound(0, (cl.time - cl.oldtime) / max(0.001, r_motionblur_vcoeff.value), 1);
9268                                 avgspeed = avgspeed * (1 - cl.motionbluralpha) + speed * cl.motionbluralpha;
9269
9270                                 speed = (avgspeed - r_motionblur_vmin.value) / max(1, r_motionblur_vmax.value - r_motionblur_vmin.value);
9271                                 speed = bound(0, speed, 1);
9272                                 speed = speed * (1 - r_motionblur_bmin.value) + r_motionblur_bmin.value;
9273
9274                                 // calculate values into a standard alpha
9275                                 cl.motionbluralpha = 1 - exp(-
9276                                                 (
9277                                                  (r_motionblur.value * speed / 80)
9278                                                  +
9279                                                  (r_damageblur.value * (cl.cshifts[CSHIFT_DAMAGE].percent / 1600))
9280                                                 )
9281                                                 /
9282                                                 max(0.0001, cl.time - cl.oldtime) // fps independent
9283                                            );
9284
9285                                 cl.motionbluralpha *= lhrandom(1 - r_motionblur_randomize.value, 1 + r_motionblur_randomize.value);
9286                                 cl.motionbluralpha = bound(0, cl.motionbluralpha, r_motionblur_maxblur.value);
9287                                 // apply the blur
9288                                 if (cl.motionbluralpha > 0 && !r_refdef.envmap)
9289                                 {
9290                                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
9291                                         GL_Color(1, 1, 1, cl.motionbluralpha);
9292                                         switch(vid.renderpath)
9293                                         {
9294                                         case RENDERPATH_GL11:
9295                                         case RENDERPATH_GL13:
9296                                         case RENDERPATH_GL20:
9297                                         case RENDERPATH_CGGL:
9298                                                 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_bloomstate.screentexcoord2f);
9299                                                 break;
9300                                         case RENDERPATH_D3D9:
9301                                         case RENDERPATH_D3D10:
9302                                         case RENDERPATH_D3D11:
9303                                                 R_Mesh_PrepareVertices_Generic_Arrays(4, r_d3dscreenvertex3f, NULL, r_bloomstate.screentexcoord2f);
9304                                                 break;
9305                                         }
9306                                         R_SetupShader_Generic(r_bloomstate.texture_screen, NULL, GL_MODULATE, 1);
9307                                         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
9308                                         r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
9309                                 }
9310                         }
9311
9312                         // copy view into the screen texture
9313                         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);
9314                         r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
9315                 }
9316                 else if (!r_bloomstate.texture_bloom)
9317                 {
9318                         // we may still have to do view tint...
9319                         if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
9320                         {
9321                                 // apply a color tint to the whole view
9322                                 R_ResetViewRendering2D();
9323                                 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
9324                                 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, NULL);
9325                                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9326                                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
9327                                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
9328                         }
9329                         break; // no screen processing, no bloom, skip it
9330                 }
9331
9332                 if (r_bloomstate.texture_bloom && !r_bloomstate.hdr)
9333                 {
9334                         // render simple bloom effect
9335                         // copy the screen and shrink it and darken it for the bloom process
9336                         R_Bloom_CopyBloomTexture(r_bloom_colorscale.value);
9337                         // make the bloom texture
9338                         R_Bloom_MakeTexture();
9339                 }
9340
9341 #if _MSC_VER >= 1400
9342 #define sscanf sscanf_s
9343 #endif
9344                 memset(uservecs, 0, sizeof(uservecs));
9345                 if (r_glsl_postprocess_uservec1_enable.integer)
9346                         sscanf(r_glsl_postprocess_uservec1.string, "%f %f %f %f", &uservecs[0][0], &uservecs[0][1], &uservecs[0][2], &uservecs[0][3]);
9347                 if (r_glsl_postprocess_uservec2_enable.integer)
9348                         sscanf(r_glsl_postprocess_uservec2.string, "%f %f %f %f", &uservecs[1][0], &uservecs[1][1], &uservecs[1][2], &uservecs[1][3]);
9349                 if (r_glsl_postprocess_uservec3_enable.integer)
9350                         sscanf(r_glsl_postprocess_uservec3.string, "%f %f %f %f", &uservecs[2][0], &uservecs[2][1], &uservecs[2][2], &uservecs[2][3]);
9351                 if (r_glsl_postprocess_uservec4_enable.integer)
9352                         sscanf(r_glsl_postprocess_uservec4.string, "%f %f %f %f", &uservecs[3][0], &uservecs[3][1], &uservecs[3][2], &uservecs[3][3]);
9353
9354                 R_ResetViewRendering2D();
9355                 GL_Color(1, 1, 1, 1);
9356                 GL_BlendFunc(GL_ONE, GL_ZERO);
9357
9358                 switch(vid.renderpath)
9359                 {
9360                 case RENDERPATH_GL20:
9361                         R_Mesh_PrepareVertices_Mesh_Arrays(4, r_screenvertex3f, NULL, NULL, NULL, NULL, r_bloomstate.screentexcoord2f, r_bloomstate.bloomtexcoord2f);
9362                         R_SetupShader_SetPermutationGLSL(SHADERMODE_POSTPROCESS, permutation);
9363                         if (r_glsl_permutation->loc_Texture_First      >= 0) R_Mesh_TexBind(GL20TU_FIRST     , r_bloomstate.texture_screen);
9364                         if (r_glsl_permutation->loc_Texture_Second     >= 0) R_Mesh_TexBind(GL20TU_SECOND    , r_bloomstate.texture_bloom );
9365                         if (r_glsl_permutation->loc_Texture_GammaRamps >= 0) R_Mesh_TexBind(GL20TU_GAMMARAMPS, r_texture_gammaramps       );
9366                         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]);
9367                         if (r_glsl_permutation->loc_PixelSize          >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelSize         , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);
9368                         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]);
9369                         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]);
9370                         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]);
9371                         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]);
9372                         if (r_glsl_permutation->loc_Saturation         >= 0) qglUniform1fARB(r_glsl_permutation->loc_Saturation        , r_glsl_saturation.value);
9373                         if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
9374                         if (r_glsl_permutation->loc_BloomColorSubtract    >= 0) qglUniform4fARB(r_glsl_permutation->loc_BloomColorSubtract   , r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 0.0f);
9375                         break;
9376                 case RENDERPATH_CGGL:
9377 #ifdef SUPPORTCG
9378                         R_Mesh_PrepareVertices_Mesh_Arrays(4, r_screenvertex3f, NULL, NULL, NULL, NULL, r_bloomstate.screentexcoord2f, r_bloomstate.bloomtexcoord2f);
9379                         R_SetupShader_SetPermutationCG(SHADERMODE_POSTPROCESS, permutation);
9380                         if (r_cg_permutation->fp_Texture_First     ) CG_BindTexture(r_cg_permutation->fp_Texture_First     , r_bloomstate.texture_screen);CHECKCGERROR
9381                         if (r_cg_permutation->fp_Texture_Second    ) CG_BindTexture(r_cg_permutation->fp_Texture_Second    , r_bloomstate.texture_bloom );CHECKCGERROR
9382                         if (r_cg_permutation->fp_Texture_GammaRamps) CG_BindTexture(r_cg_permutation->fp_Texture_GammaRamps, r_texture_gammaramps       );CHECKCGERROR
9383                         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
9384                         if (r_cg_permutation->fp_PixelSize         ) cgGLSetParameter2f(     r_cg_permutation->fp_PixelSize         , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);CHECKCGERROR
9385                         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
9386                         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
9387                         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
9388                         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
9389                         if (r_cg_permutation->fp_Saturation        ) cgGLSetParameter1f(     r_cg_permutation->fp_Saturation        , r_glsl_saturation.value);CHECKCGERROR
9390                         if (r_cg_permutation->fp_PixelToScreenTexCoord) cgGLSetParameter2f(r_cg_permutation->fp_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);CHECKCGERROR
9391                         if (r_cg_permutation->fp_BloomColorSubtract   ) cgGLSetParameter4f(r_cg_permutation->fp_BloomColorSubtract   , r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 0.0f);
9392 #endif
9393                         break;
9394                 case RENDERPATH_D3D9:
9395 #ifdef SUPPORTD3D
9396                         // D3D has upside down Y coords, the easiest way to flip this is to flip the screen vertices rather than the texcoords, so we just use a different array for that...
9397                         R_Mesh_PrepareVertices_Mesh_Arrays(4, r_d3dscreenvertex3f, NULL, NULL, NULL, NULL, r_bloomstate.screentexcoord2f, r_bloomstate.bloomtexcoord2f);
9398                         R_SetupShader_SetPermutationHLSL(SHADERMODE_POSTPROCESS, permutation);
9399                         R_Mesh_TexBind(GL20TU_FIRST     , r_bloomstate.texture_screen);
9400                         R_Mesh_TexBind(GL20TU_SECOND    , r_bloomstate.texture_bloom );
9401                         R_Mesh_TexBind(GL20TU_GAMMARAMPS, r_texture_gammaramps       );
9402                         hlslPSSetParameter4f(D3DPSREGISTER_ViewTintColor        , r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
9403                         hlslPSSetParameter2f(D3DPSREGISTER_PixelSize            , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);
9404                         hlslPSSetParameter4f(D3DPSREGISTER_UserVec1             , uservecs[0][0], uservecs[0][1], uservecs[0][2], uservecs[0][3]);
9405                         hlslPSSetParameter4f(D3DPSREGISTER_UserVec2             , uservecs[1][0], uservecs[1][1], uservecs[1][2], uservecs[1][3]);
9406                         hlslPSSetParameter4f(D3DPSREGISTER_UserVec3             , uservecs[2][0], uservecs[2][1], uservecs[2][2], uservecs[2][3]);
9407                         hlslPSSetParameter4f(D3DPSREGISTER_UserVec4             , uservecs[3][0], uservecs[3][1], uservecs[3][2], uservecs[3][3]);
9408                         hlslPSSetParameter1f(D3DPSREGISTER_Saturation           , r_glsl_saturation.value);
9409                         hlslPSSetParameter2f(D3DPSREGISTER_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);
9410                         hlslPSSetParameter4f(D3DPSREGISTER_BloomColorSubtract   , r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 0.0f);
9411 #endif
9412                         break;
9413                 case RENDERPATH_D3D10:
9414                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
9415                         break;
9416                 case RENDERPATH_D3D11:
9417                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
9418                         break;
9419                 default:
9420                         break;
9421                 }
9422                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
9423                 r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
9424                 break;
9425         case RENDERPATH_GL13:
9426         case RENDERPATH_GL11:
9427                 if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
9428                 {
9429                         // apply a color tint to the whole view
9430                         R_ResetViewRendering2D();
9431                         GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
9432                         R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, NULL);
9433                         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9434                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
9435                         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
9436                 }
9437                 break;
9438         }
9439 }
9440
9441 matrix4x4_t r_waterscrollmatrix;
9442
9443 void R_UpdateFogColor(void) // needs to be called before HDR subrender too, as that changes colorscale!
9444 {
9445         if (r_refdef.fog_density)
9446         {
9447                 r_refdef.fogcolor[0] = r_refdef.fog_red;
9448                 r_refdef.fogcolor[1] = r_refdef.fog_green;
9449                 r_refdef.fogcolor[2] = r_refdef.fog_blue;
9450
9451                 Vector4Set(r_refdef.fogplane, 0, 0, 1, -r_refdef.fog_height);
9452                 r_refdef.fogplaneviewdist = DotProduct(r_refdef.fogplane, r_refdef.view.origin) + r_refdef.fogplane[3];
9453                 r_refdef.fogplaneviewabove = r_refdef.fogplaneviewdist >= 0;
9454                 r_refdef.fogheightfade = -0.5f/max(0.125f, r_refdef.fog_fadedepth);
9455
9456                 {
9457                         vec3_t fogvec;
9458                         VectorCopy(r_refdef.fogcolor, fogvec);
9459                         //   color.rgb *= ContrastBoost * SceneBrightness;
9460                         VectorScale(fogvec, r_refdef.view.colorscale, fogvec);
9461                         r_refdef.fogcolor[0] = bound(0.0f, fogvec[0], 1.0f);
9462                         r_refdef.fogcolor[1] = bound(0.0f, fogvec[1], 1.0f);
9463                         r_refdef.fogcolor[2] = bound(0.0f, fogvec[2], 1.0f);
9464                 }
9465         }
9466 }
9467
9468 void R_UpdateVariables(void)
9469 {
9470         R_Textures_Frame();
9471
9472         r_refdef.scene.ambient = r_ambient.value * (1.0f / 64.0f);
9473
9474         r_refdef.farclip = r_farclip_base.value;
9475         if (r_refdef.scene.worldmodel)
9476                 r_refdef.farclip += r_refdef.scene.worldmodel->radius * r_farclip_world.value * 2;
9477         r_refdef.nearclip = bound (0.001f, r_nearclip.value, r_refdef.farclip - 1.0f);
9478
9479         if (r_shadow_frontsidecasting.integer < 0 || r_shadow_frontsidecasting.integer > 1)
9480                 Cvar_SetValueQuick(&r_shadow_frontsidecasting, 1);
9481         r_refdef.polygonfactor = 0;
9482         r_refdef.polygonoffset = 0;
9483         r_refdef.shadowpolygonfactor = r_refdef.polygonfactor + r_shadow_polygonfactor.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
9484         r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_polygonoffset.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
9485
9486         r_refdef.scene.rtworld = r_shadow_realtime_world.integer != 0;
9487         r_refdef.scene.rtworldshadows = r_shadow_realtime_world_shadows.integer && vid.stencil;
9488         r_refdef.scene.rtdlight = r_shadow_realtime_dlight.integer != 0 && !gl_flashblend.integer && r_dynamic.integer;
9489         r_refdef.scene.rtdlightshadows = r_refdef.scene.rtdlight && r_shadow_realtime_dlight_shadows.integer && vid.stencil;
9490         r_refdef.lightmapintensity = r_refdef.scene.rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
9491         if (FAKELIGHT_ENABLED)
9492         {
9493                 r_refdef.lightmapintensity *= r_fakelight_intensity.value;
9494         }
9495         if (r_showsurfaces.integer)
9496         {
9497                 r_refdef.scene.rtworld = false;
9498                 r_refdef.scene.rtworldshadows = false;
9499                 r_refdef.scene.rtdlight = false;
9500                 r_refdef.scene.rtdlightshadows = false;
9501                 r_refdef.lightmapintensity = 0;
9502         }
9503
9504         if (gamemode == GAME_NEHAHRA)
9505         {
9506                 if (gl_fogenable.integer)
9507                 {
9508                         r_refdef.oldgl_fogenable = true;
9509                         r_refdef.fog_density = gl_fogdensity.value;
9510                         r_refdef.fog_red = gl_fogred.value;
9511                         r_refdef.fog_green = gl_foggreen.value;
9512                         r_refdef.fog_blue = gl_fogblue.value;
9513                         r_refdef.fog_alpha = 1;
9514                         r_refdef.fog_start = 0;
9515                         r_refdef.fog_end = gl_skyclip.value;
9516                         r_refdef.fog_height = 1<<30;
9517                         r_refdef.fog_fadedepth = 128;
9518                 }
9519                 else if (r_refdef.oldgl_fogenable)
9520                 {
9521                         r_refdef.oldgl_fogenable = false;
9522                         r_refdef.fog_density = 0;
9523                         r_refdef.fog_red = 0;
9524                         r_refdef.fog_green = 0;
9525                         r_refdef.fog_blue = 0;
9526                         r_refdef.fog_alpha = 0;
9527                         r_refdef.fog_start = 0;
9528                         r_refdef.fog_end = 0;
9529                         r_refdef.fog_height = 1<<30;
9530                         r_refdef.fog_fadedepth = 128;
9531                 }
9532         }
9533
9534         r_refdef.fog_alpha = bound(0, r_refdef.fog_alpha, 1);
9535         r_refdef.fog_start = max(0, r_refdef.fog_start);
9536         r_refdef.fog_end = max(r_refdef.fog_start + 0.01, r_refdef.fog_end);
9537
9538         // R_UpdateFogColor(); // why? R_RenderScene does it anyway
9539
9540         if (r_refdef.fog_density && r_drawfog.integer)
9541         {
9542                 r_refdef.fogenabled = true;
9543                 // this is the point where the fog reaches 0.9986 alpha, which we
9544                 // consider a good enough cutoff point for the texture
9545                 // (0.9986 * 256 == 255.6)
9546                 if (r_fog_exp2.integer)
9547                         r_refdef.fogrange = 32 / (r_refdef.fog_density * r_refdef.fog_density) + r_refdef.fog_start;
9548                 else
9549                         r_refdef.fogrange = 2048 / r_refdef.fog_density + r_refdef.fog_start;
9550                 r_refdef.fogrange = bound(r_refdef.fog_start, r_refdef.fogrange, r_refdef.fog_end);
9551                 r_refdef.fograngerecip = 1.0f / r_refdef.fogrange;
9552                 r_refdef.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * r_refdef.fograngerecip;
9553                 if (strcmp(r_refdef.fogheighttexturename, r_refdef.fog_height_texturename))
9554                         R_BuildFogHeightTexture();
9555                 // fog color was already set
9556                 // update the fog texture
9557                 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)
9558                         R_BuildFogTexture();
9559                 r_refdef.fog_height_texcoordscale = 1.0f / max(0.125f, r_refdef.fog_fadedepth);
9560                 r_refdef.fog_height_tablescale = r_refdef.fog_height_tablesize * r_refdef.fog_height_texcoordscale;
9561         }
9562         else
9563                 r_refdef.fogenabled = false;
9564
9565         switch(vid.renderpath)
9566         {
9567         case RENDERPATH_GL20:
9568         case RENDERPATH_CGGL:
9569         case RENDERPATH_D3D9:
9570         case RENDERPATH_D3D10:
9571         case RENDERPATH_D3D11:
9572                 if(v_glslgamma.integer && !vid_gammatables_trivial)
9573                 {
9574                         if(!r_texture_gammaramps || vid_gammatables_serial != r_texture_gammaramps_serial)
9575                         {
9576                                 // build GLSL gamma texture
9577 #define RAMPWIDTH 256
9578                                 unsigned short ramp[RAMPWIDTH * 3];
9579                                 unsigned char rampbgr[RAMPWIDTH][4];
9580                                 int i;
9581
9582                                 r_texture_gammaramps_serial = vid_gammatables_serial;
9583
9584                                 VID_BuildGammaTables(&ramp[0], RAMPWIDTH);
9585                                 for(i = 0; i < RAMPWIDTH; ++i)
9586                                 {
9587                                         rampbgr[i][0] = (unsigned char) (ramp[i + 2 * RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
9588                                         rampbgr[i][1] = (unsigned char) (ramp[i + RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
9589                                         rampbgr[i][2] = (unsigned char) (ramp[i] * 255.0 / 65535.0 + 0.5);
9590                                         rampbgr[i][3] = 0;
9591                                 }
9592                                 if (r_texture_gammaramps)
9593                                 {
9594                                         R_UpdateTexture(r_texture_gammaramps, &rampbgr[0][0], 0, 0, RAMPWIDTH, 1);
9595                                 }
9596                                 else
9597                                 {
9598                                         r_texture_gammaramps = R_LoadTexture2D(r_main_texturepool, "gammaramps", RAMPWIDTH, 1, &rampbgr[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL);
9599                                 }
9600                         }
9601                 }
9602                 else
9603                 {
9604                         // remove GLSL gamma texture
9605                 }
9606                 break;
9607         case RENDERPATH_GL13:
9608         case RENDERPATH_GL11:
9609                 break;
9610         }
9611 }
9612
9613 static r_refdef_scene_type_t r_currentscenetype = RST_CLIENT;
9614 static r_refdef_scene_t r_scenes_store[ RST_COUNT ];
9615 /*
9616 ================
9617 R_SelectScene
9618 ================
9619 */
9620 void R_SelectScene( r_refdef_scene_type_t scenetype ) {
9621         if( scenetype != r_currentscenetype ) {
9622                 // store the old scenetype
9623                 r_scenes_store[ r_currentscenetype ] = r_refdef.scene;
9624                 r_currentscenetype = scenetype;
9625                 // move in the new scene
9626                 r_refdef.scene = r_scenes_store[ r_currentscenetype ];
9627         }
9628 }
9629
9630 /*
9631 ================
9632 R_GetScenePointer
9633 ================
9634 */
9635 r_refdef_scene_t * R_GetScenePointer( r_refdef_scene_type_t scenetype )
9636 {
9637         // of course, we could also add a qboolean that provides a lock state and a ReleaseScenePointer function..
9638         if( scenetype == r_currentscenetype ) {
9639                 return &r_refdef.scene;
9640         } else {
9641                 return &r_scenes_store[ scenetype ];
9642         }
9643 }
9644
9645 /*
9646 ================
9647 R_RenderView
9648 ================
9649 */
9650 void R_RenderView(void)
9651 {
9652         matrix4x4_t originalmatrix = r_refdef.view.matrix, offsetmatrix;
9653         if (r_timereport_active)
9654                 R_TimeReport("start");
9655         r_textureframe++; // used only by R_GetCurrentTexture
9656         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
9657
9658         if(R_CompileShader_CheckStaticParms())
9659                 R_GLSL_Restart_f();
9660
9661         if (!r_drawentities.integer)
9662                 r_refdef.scene.numentities = 0;
9663
9664         R_AnimCache_ClearCache();
9665         R_FrameData_NewFrame();
9666
9667         /* adjust for stereo display */
9668         if(R_Stereo_Active())
9669         {
9670                 Matrix4x4_CreateFromQuakeEntity(&offsetmatrix, 0, r_stereo_separation.value * (0.5f - r_stereo_side), 0, 0, r_stereo_angle.value * (0.5f - r_stereo_side), 0, 1);
9671                 Matrix4x4_Concat(&r_refdef.view.matrix, &originalmatrix, &offsetmatrix);
9672         }
9673
9674         if (r_refdef.view.isoverlay)
9675         {
9676                 // TODO: FIXME: move this into its own backend function maybe? [2/5/2008 Andreas]
9677                 GL_Clear(GL_DEPTH_BUFFER_BIT, NULL, 1.0f, 0);
9678                 R_TimeReport("depthclear");
9679
9680                 r_refdef.view.showdebug = false;
9681
9682                 r_waterstate.enabled = false;
9683                 r_waterstate.numwaterplanes = 0;
9684
9685                 R_RenderScene();
9686
9687                 r_refdef.view.matrix = originalmatrix;
9688
9689                 CHECKGLERROR
9690                 return;
9691         }
9692
9693         if (!r_refdef.scene.entities || r_refdef.view.width * r_refdef.view.height == 0 || !r_renderview.integer || cl_videoplaying/* || !r_refdef.scene.worldmodel*/)
9694         {
9695                 r_refdef.view.matrix = originalmatrix;
9696                 return; //Host_Error ("R_RenderView: NULL worldmodel");
9697         }
9698
9699         r_refdef.view.colorscale = r_hdr_scenebrightness.value;
9700
9701         R_RenderView_UpdateViewVectors();
9702
9703         R_Shadow_UpdateWorldLightSelection();
9704
9705         R_Bloom_StartFrame();
9706         R_Water_StartFrame();
9707
9708         CHECKGLERROR
9709         if (r_timereport_active)
9710                 R_TimeReport("viewsetup");
9711
9712         R_ResetViewRendering3D();
9713
9714         if (r_refdef.view.clear || r_refdef.fogenabled)
9715         {
9716                 R_ClearScreen(r_refdef.fogenabled);
9717                 if (r_timereport_active)
9718                         R_TimeReport("viewclear");
9719         }
9720         r_refdef.view.clear = true;
9721
9722         // this produces a bloom texture to be used in R_BlendView() later
9723         if (r_hdr.integer && r_bloomstate.bloomwidth)
9724         {
9725                 R_HDR_RenderBloomTexture();
9726                 // we have to bump the texture frame again because r_refdef.view.colorscale is cached in the textures
9727                 r_textureframe++; // used only by R_GetCurrentTexture
9728         }
9729
9730         r_refdef.view.showdebug = true;
9731
9732         R_View_Update();
9733         if (r_timereport_active)
9734                 R_TimeReport("visibility");
9735
9736         r_waterstate.numwaterplanes = 0;
9737         if (r_waterstate.enabled)
9738                 R_RenderWaterPlanes();
9739
9740         R_RenderScene();
9741         r_waterstate.numwaterplanes = 0;
9742
9743         R_BlendView();
9744         if (r_timereport_active)
9745                 R_TimeReport("blendview");
9746
9747         GL_Scissor(0, 0, vid.width, vid.height);
9748         GL_ScissorTest(false);
9749
9750         r_refdef.view.matrix = originalmatrix;
9751
9752         CHECKGLERROR
9753 }
9754
9755 void R_RenderWaterPlanes(void)
9756 {
9757         if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawAddWaterPlanes)
9758         {
9759                 r_refdef.scene.worldmodel->DrawAddWaterPlanes(r_refdef.scene.worldentity);
9760                 if (r_timereport_active)
9761                         R_TimeReport("waterworld");
9762         }
9763
9764         // don't let sound skip if going slow
9765         if (r_refdef.scene.extraupdate)
9766                 S_ExtraUpdate ();
9767
9768         R_DrawModelsAddWaterPlanes();
9769         if (r_timereport_active)
9770                 R_TimeReport("watermodels");
9771
9772         if (r_waterstate.numwaterplanes)
9773         {
9774                 R_Water_ProcessPlanes();
9775                 if (r_timereport_active)
9776                         R_TimeReport("waterscenes");
9777         }
9778 }
9779
9780 extern void R_DrawLightningBeams (void);
9781 extern void VM_CL_AddPolygonsToMeshQueue (void);
9782 extern void R_DrawPortals (void);
9783 extern cvar_t cl_locs_show;
9784 static void R_DrawLocs(void);
9785 static void R_DrawEntityBBoxes(void);
9786 static void R_DrawModelDecals(void);
9787 extern void R_DrawModelShadows(void);
9788 extern void R_DrawModelShadowMaps(void);
9789 extern cvar_t cl_decals_newsystem;
9790 extern qboolean r_shadow_usingdeferredprepass;
9791 void R_RenderScene(void)
9792 {
9793         qboolean shadowmapping = false;
9794
9795         if (r_timereport_active)
9796                 R_TimeReport("beginscene");
9797
9798         r_refdef.stats.renders++;
9799
9800         R_UpdateFogColor();
9801
9802         // don't let sound skip if going slow
9803         if (r_refdef.scene.extraupdate)
9804                 S_ExtraUpdate ();
9805
9806         R_MeshQueue_BeginScene();
9807
9808         R_SkyStartFrame();
9809
9810         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);
9811
9812         if (r_timereport_active)
9813                 R_TimeReport("skystartframe");
9814
9815         if (cl.csqc_vidvars.drawworld)
9816         {
9817                 // don't let sound skip if going slow
9818                 if (r_refdef.scene.extraupdate)
9819                         S_ExtraUpdate ();
9820
9821                 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawSky)
9822                 {
9823                         r_refdef.scene.worldmodel->DrawSky(r_refdef.scene.worldentity);
9824                         if (r_timereport_active)
9825                                 R_TimeReport("worldsky");
9826                 }
9827
9828                 if (R_DrawBrushModelsSky() && r_timereport_active)
9829                         R_TimeReport("bmodelsky");
9830
9831                 if (skyrendermasked && skyrenderlater)
9832                 {
9833                         // we have to force off the water clipping plane while rendering sky
9834                         R_SetupView(false);
9835                         R_Sky();
9836                         R_SetupView(true);
9837                         if (r_timereport_active)
9838                                 R_TimeReport("sky");
9839                 }
9840         }
9841
9842         R_AnimCache_CacheVisibleEntities();
9843         if (r_timereport_active)
9844                 R_TimeReport("animation");
9845
9846         R_Shadow_PrepareLights();
9847         if (r_shadows.integer > 0 && r_refdef.lightmapintensity > 0)
9848                 R_Shadow_PrepareModelShadows();
9849         if (r_timereport_active)
9850                 R_TimeReport("preparelights");
9851
9852         if (R_Shadow_ShadowMappingEnabled())
9853                 shadowmapping = true;
9854
9855         if (r_shadow_usingdeferredprepass)
9856                 R_Shadow_DrawPrepass();
9857
9858         if (r_depthfirst.integer >= 1 && cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawDepth)
9859         {
9860                 r_refdef.scene.worldmodel->DrawDepth(r_refdef.scene.worldentity);
9861                 if (r_timereport_active)
9862                         R_TimeReport("worlddepth");
9863         }
9864         if (r_depthfirst.integer >= 2)
9865         {
9866                 R_DrawModelsDepth();
9867                 if (r_timereport_active)
9868                         R_TimeReport("modeldepth");
9869         }
9870
9871         if (r_shadows.integer >= 2 && shadowmapping && r_refdef.lightmapintensity > 0)
9872         {
9873                 R_DrawModelShadowMaps();
9874                 R_ResetViewRendering3D();
9875                 // don't let sound skip if going slow
9876                 if (r_refdef.scene.extraupdate)
9877                         S_ExtraUpdate ();
9878         }
9879
9880         if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->Draw)
9881         {
9882                 r_refdef.scene.worldmodel->Draw(r_refdef.scene.worldentity);
9883                 if (r_timereport_active)
9884                         R_TimeReport("world");
9885         }
9886
9887         // don't let sound skip if going slow
9888         if (r_refdef.scene.extraupdate)
9889                 S_ExtraUpdate ();
9890
9891         R_DrawModels();
9892         if (r_timereport_active)
9893                 R_TimeReport("models");
9894
9895         // don't let sound skip if going slow
9896         if (r_refdef.scene.extraupdate)
9897                 S_ExtraUpdate ();
9898
9899         if ((r_shadows.integer == 1 || (r_shadows.integer > 0 && !shadowmapping)) && !r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0)
9900         {
9901                 R_DrawModelShadows();
9902                 R_ResetViewRendering3D();
9903                 // don't let sound skip if going slow
9904                 if (r_refdef.scene.extraupdate)
9905                         S_ExtraUpdate ();
9906         }
9907
9908         if (!r_shadow_usingdeferredprepass)
9909         {
9910                 R_Shadow_DrawLights();
9911                 if (r_timereport_active)
9912                         R_TimeReport("rtlights");
9913         }
9914
9915         // don't let sound skip if going slow
9916         if (r_refdef.scene.extraupdate)
9917                 S_ExtraUpdate ();
9918
9919         if ((r_shadows.integer == 1 || (r_shadows.integer > 0 && !shadowmapping)) && r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0)
9920         {
9921                 R_DrawModelShadows();
9922                 R_ResetViewRendering3D();
9923                 // don't let sound skip if going slow
9924                 if (r_refdef.scene.extraupdate)
9925                         S_ExtraUpdate ();
9926         }
9927
9928         if (cl.csqc_vidvars.drawworld)
9929         {
9930                 if (cl_decals_newsystem.integer)
9931                 {
9932                         R_DrawModelDecals();
9933                         if (r_timereport_active)
9934                                 R_TimeReport("modeldecals");
9935                 }
9936                 else
9937                 {
9938                         R_DrawDecals();
9939                         if (r_timereport_active)
9940                                 R_TimeReport("decals");
9941                 }
9942
9943                 R_DrawParticles();
9944                 if (r_timereport_active)
9945                         R_TimeReport("particles");
9946
9947                 R_DrawExplosions();
9948                 if (r_timereport_active)
9949                         R_TimeReport("explosions");
9950
9951                 R_DrawLightningBeams();
9952                 if (r_timereport_active)
9953                         R_TimeReport("lightning");
9954         }
9955
9956         VM_CL_AddPolygonsToMeshQueue();
9957
9958         if (r_refdef.view.showdebug)
9959         {
9960                 if (cl_locs_show.integer)
9961                 {
9962                         R_DrawLocs();
9963                         if (r_timereport_active)
9964                                 R_TimeReport("showlocs");
9965                 }
9966
9967                 if (r_drawportals.integer)
9968                 {
9969                         R_DrawPortals();
9970                         if (r_timereport_active)
9971                                 R_TimeReport("portals");
9972                 }
9973
9974                 if (r_showbboxes.value > 0)
9975                 {
9976                         R_DrawEntityBBoxes();
9977                         if (r_timereport_active)
9978                                 R_TimeReport("bboxes");
9979                 }
9980         }
9981
9982         R_MeshQueue_RenderTransparent();
9983         if (r_timereport_active)
9984                 R_TimeReport("drawtrans");
9985
9986         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))
9987         {
9988                 r_refdef.scene.worldmodel->DrawDebug(r_refdef.scene.worldentity);
9989                 if (r_timereport_active)
9990                         R_TimeReport("worlddebug");
9991                 R_DrawModelsDebug();
9992                 if (r_timereport_active)
9993                         R_TimeReport("modeldebug");
9994         }
9995
9996         if (cl.csqc_vidvars.drawworld)
9997         {
9998                 R_Shadow_DrawCoronas();
9999                 if (r_timereport_active)
10000                         R_TimeReport("coronas");
10001         }
10002
10003 #if 0
10004         {
10005                 GL_DepthTest(false);
10006                 qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
10007                 GL_Color(1, 1, 1, 1);
10008                 qglBegin(GL_POLYGON);
10009                 qglVertex3f(r_refdef.view.frustumcorner[0][0], r_refdef.view.frustumcorner[0][1], r_refdef.view.frustumcorner[0][2]);
10010                 qglVertex3f(r_refdef.view.frustumcorner[1][0], r_refdef.view.frustumcorner[1][1], r_refdef.view.frustumcorner[1][2]);
10011                 qglVertex3f(r_refdef.view.frustumcorner[3][0], r_refdef.view.frustumcorner[3][1], r_refdef.view.frustumcorner[3][2]);
10012                 qglVertex3f(r_refdef.view.frustumcorner[2][0], r_refdef.view.frustumcorner[2][1], r_refdef.view.frustumcorner[2][2]);
10013                 qglEnd();
10014                 qglBegin(GL_POLYGON);
10015                 qglVertex3f(r_refdef.view.frustumcorner[0][0] + 1000 * r_refdef.view.forward[0], r_refdef.view.frustumcorner[0][1] + 1000 * r_refdef.view.forward[1], r_refdef.view.frustumcorner[0][2] + 1000 * r_refdef.view.forward[2]);
10016                 qglVertex3f(r_refdef.view.frustumcorner[1][0] + 1000 * r_refdef.view.forward[0], r_refdef.view.frustumcorner[1][1] + 1000 * r_refdef.view.forward[1], r_refdef.view.frustumcorner[1][2] + 1000 * r_refdef.view.forward[2]);
10017                 qglVertex3f(r_refdef.view.frustumcorner[3][0] + 1000 * r_refdef.view.forward[0], r_refdef.view.frustumcorner[3][1] + 1000 * r_refdef.view.forward[1], r_refdef.view.frustumcorner[3][2] + 1000 * r_refdef.view.forward[2]);
10018                 qglVertex3f(r_refdef.view.frustumcorner[2][0] + 1000 * r_refdef.view.forward[0], r_refdef.view.frustumcorner[2][1] + 1000 * r_refdef.view.forward[1], r_refdef.view.frustumcorner[2][2] + 1000 * r_refdef.view.forward[2]);
10019                 qglEnd();
10020                 qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
10021         }
10022 #endif
10023
10024         // don't let sound skip if going slow
10025         if (r_refdef.scene.extraupdate)
10026                 S_ExtraUpdate ();
10027
10028         R_ResetViewRendering2D();
10029 }
10030
10031 static const unsigned short bboxelements[36] =
10032 {
10033         5, 1, 3, 5, 3, 7,
10034         6, 2, 0, 6, 0, 4,
10035         7, 3, 2, 7, 2, 6,
10036         4, 0, 1, 4, 1, 5,
10037         4, 5, 7, 4, 7, 6,
10038         1, 0, 2, 1, 2, 3,
10039 };
10040
10041 void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
10042 {
10043         int i;
10044         float *v, *c, f1, f2, vertex3f[8*3], color4f[8*4];
10045
10046         RSurf_ActiveWorldEntity();
10047
10048         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
10049         GL_DepthMask(false);
10050         GL_DepthRange(0, 1);
10051         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
10052 //      R_Mesh_ResetTextureState();
10053
10054         vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2]; //
10055         vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2];
10056         vertex3f[ 6] = mins[0];vertex3f[ 7] = maxs[1];vertex3f[ 8] = mins[2];
10057         vertex3f[ 9] = maxs[0];vertex3f[10] = maxs[1];vertex3f[11] = mins[2];
10058         vertex3f[12] = mins[0];vertex3f[13] = mins[1];vertex3f[14] = maxs[2];
10059         vertex3f[15] = maxs[0];vertex3f[16] = mins[1];vertex3f[17] = maxs[2];
10060         vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
10061         vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
10062         R_FillColors(color4f, 8, cr, cg, cb, ca);
10063         if (r_refdef.fogenabled)
10064         {
10065                 for (i = 0, v = vertex3f, c = color4f;i < 8;i++, v += 3, c += 4)
10066                 {
10067                         f1 = RSurf_FogVertex(v);
10068                         f2 = 1 - f1;
10069                         c[0] = c[0] * f1 + r_refdef.fogcolor[0] * f2;
10070                         c[1] = c[1] * f1 + r_refdef.fogcolor[1] * f2;
10071                         c[2] = c[2] * f1 + r_refdef.fogcolor[2] * f2;
10072                 }
10073         }
10074         R_Mesh_PrepareVertices_Generic_Arrays(8, vertex3f, color4f, NULL);
10075         R_Mesh_ResetTextureState();
10076         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
10077         R_Mesh_Draw(0, 8, 0, 12, NULL, NULL, 0, bboxelements, NULL, 0);
10078 }
10079
10080 static void R_DrawEntityBBoxes_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
10081 {
10082         int i;
10083         float color[4];
10084         prvm_edict_t *edict;
10085         prvm_prog_t *prog_save = prog;
10086
10087         // this function draws bounding boxes of server entities
10088         if (!sv.active)
10089                 return;
10090
10091         GL_CullFace(GL_NONE);
10092         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
10093
10094         prog = 0;
10095         SV_VM_Begin();
10096         for (i = 0;i < numsurfaces;i++)
10097         {
10098                 edict = PRVM_EDICT_NUM(surfacelist[i]);
10099                 switch ((int)edict->fields.server->solid)
10100                 {
10101                         case SOLID_NOT:      Vector4Set(color, 1, 1, 1, 0.05);break;
10102                         case SOLID_TRIGGER:  Vector4Set(color, 1, 0, 1, 0.10);break;
10103                         case SOLID_BBOX:     Vector4Set(color, 0, 1, 0, 0.10);break;
10104                         case SOLID_SLIDEBOX: Vector4Set(color, 1, 0, 0, 0.10);break;
10105                         case SOLID_BSP:      Vector4Set(color, 0, 0, 1, 0.05);break;
10106                         default:             Vector4Set(color, 0, 0, 0, 0.50);break;
10107                 }
10108                 color[3] *= r_showbboxes.value;
10109                 color[3] = bound(0, color[3], 1);
10110                 GL_DepthTest(!r_showdisabledepthtest.integer);
10111                 GL_CullFace(r_refdef.view.cullface_front);
10112                 R_DrawBBoxMesh(edict->priv.server->areamins, edict->priv.server->areamaxs, color[0], color[1], color[2], color[3]);
10113         }
10114         SV_VM_End();
10115         prog = prog_save;
10116 }
10117
10118 static void R_DrawEntityBBoxes(void)
10119 {
10120         int i;
10121         prvm_edict_t *edict;
10122         vec3_t center;
10123         prvm_prog_t *prog_save = prog;
10124
10125         // this function draws bounding boxes of server entities
10126         if (!sv.active)
10127                 return;
10128
10129         prog = 0;
10130         SV_VM_Begin();
10131         for (i = 0;i < prog->num_edicts;i++)
10132         {
10133                 edict = PRVM_EDICT_NUM(i);
10134                 if (edict->priv.server->free)
10135                         continue;
10136                 // exclude the following for now, as they don't live in world coordinate space and can't be solid:
10137                 if(PRVM_EDICTFIELDVALUE(edict, prog->fieldoffsets.tag_entity)->edict != 0)
10138                         continue;
10139                 if(PRVM_EDICTFIELDVALUE(edict, prog->fieldoffsets.viewmodelforclient)->edict != 0)
10140                         continue;
10141                 VectorLerp(edict->priv.server->areamins, 0.5f, edict->priv.server->areamaxs, center);
10142                 R_MeshQueue_AddTransparent(center, R_DrawEntityBBoxes_Callback, (entity_render_t *)NULL, i, (rtlight_t *)NULL);
10143         }
10144         SV_VM_End();
10145         prog = prog_save;
10146 }
10147
10148 static const int nomodelelement3i[24] =
10149 {
10150         5, 2, 0,
10151         5, 1, 2,
10152         5, 0, 3,
10153         5, 3, 1,
10154         0, 2, 4,
10155         2, 1, 4,
10156         3, 0, 4,
10157         1, 3, 4
10158 };
10159
10160 static const unsigned short nomodelelement3s[24] =
10161 {
10162         5, 2, 0,
10163         5, 1, 2,
10164         5, 0, 3,
10165         5, 3, 1,
10166         0, 2, 4,
10167         2, 1, 4,
10168         3, 0, 4,
10169         1, 3, 4
10170 };
10171
10172 static const float nomodelvertex3f[6*3] =
10173 {
10174         -16,   0,   0,
10175          16,   0,   0,
10176           0, -16,   0,
10177           0,  16,   0,
10178           0,   0, -16,
10179           0,   0,  16
10180 };
10181
10182 static const float nomodelcolor4f[6*4] =
10183 {
10184         0.0f, 0.0f, 0.5f, 1.0f,
10185         0.0f, 0.0f, 0.5f, 1.0f,
10186         0.0f, 0.5f, 0.0f, 1.0f,
10187         0.0f, 0.5f, 0.0f, 1.0f,
10188         0.5f, 0.0f, 0.0f, 1.0f,
10189         0.5f, 0.0f, 0.0f, 1.0f
10190 };
10191
10192 void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
10193 {
10194         int i;
10195         float f1, f2, *c;
10196         float color4f[6*4];
10197
10198         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);
10199
10200         // this is only called once per entity so numsurfaces is always 1, and
10201         // surfacelist is always {0}, so this code does not handle batches
10202
10203         if (rsurface.ent_flags & RENDER_ADDITIVE)
10204         {
10205                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
10206                 GL_DepthMask(false);
10207         }
10208         else if (rsurface.colormod[3] < 1)
10209         {
10210                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
10211                 GL_DepthMask(false);
10212         }
10213         else
10214         {
10215                 GL_BlendFunc(GL_ONE, GL_ZERO);
10216                 GL_DepthMask(true);
10217         }
10218         GL_DepthRange(0, (rsurface.ent_flags & RENDER_VIEWMODEL) ? 0.0625 : 1);
10219         GL_PolygonOffset(rsurface.basepolygonfactor, rsurface.basepolygonoffset);
10220         GL_DepthTest(!(rsurface.ent_flags & RENDER_NODEPTHTEST));
10221         GL_CullFace((rsurface.ent_flags & RENDER_DOUBLESIDED) ? GL_NONE : r_refdef.view.cullface_back);
10222         memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
10223         for (i = 0, c = color4f;i < 6;i++, c += 4)
10224         {
10225                 c[0] *= rsurface.colormod[0];
10226                 c[1] *= rsurface.colormod[1];
10227                 c[2] *= rsurface.colormod[2];
10228                 c[3] *= rsurface.colormod[3];
10229         }
10230         if (r_refdef.fogenabled)
10231         {
10232                 for (i = 0, c = color4f;i < 6;i++, c += 4)
10233                 {
10234                         f1 = RSurf_FogVertex(nomodelvertex3f + 3*i);
10235                         f2 = 1 - f1;
10236                         c[0] = (c[0] * f1 + r_refdef.fogcolor[0] * f2);
10237                         c[1] = (c[1] * f1 + r_refdef.fogcolor[1] * f2);
10238                         c[2] = (c[2] * f1 + r_refdef.fogcolor[2] * f2);
10239                 }
10240         }
10241 //      R_Mesh_ResetTextureState();
10242         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
10243         R_Mesh_PrepareVertices_Generic_Arrays(6, nomodelvertex3f, color4f, NULL);
10244         R_Mesh_Draw(0, 6, 0, 8, nomodelelement3i, NULL, 0, nomodelelement3s, NULL, 0);
10245 }
10246
10247 void R_DrawNoModel(entity_render_t *ent)
10248 {
10249         vec3_t org;
10250         Matrix4x4_OriginFromMatrix(&ent->matrix, org);
10251         if ((ent->flags & RENDER_ADDITIVE) || (ent->alpha < 1))
10252                 R_MeshQueue_AddTransparent(ent->flags & RENDER_NODEPTHTEST ? r_refdef.view.origin : org, R_DrawNoModel_TransparentCallback, ent, 0, rsurface.rtlight);
10253         else
10254                 R_DrawNoModel_TransparentCallback(ent, rsurface.rtlight, 0, NULL);
10255 }
10256
10257 void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
10258 {
10259         vec3_t right1, right2, diff, normal;
10260
10261         VectorSubtract (org2, org1, normal);
10262
10263         // calculate 'right' vector for start
10264         VectorSubtract (r_refdef.view.origin, org1, diff);
10265         CrossProduct (normal, diff, right1);
10266         VectorNormalize (right1);
10267
10268         // calculate 'right' vector for end
10269         VectorSubtract (r_refdef.view.origin, org2, diff);
10270         CrossProduct (normal, diff, right2);
10271         VectorNormalize (right2);
10272
10273         vert[ 0] = org1[0] + width * right1[0];
10274         vert[ 1] = org1[1] + width * right1[1];
10275         vert[ 2] = org1[2] + width * right1[2];
10276         vert[ 3] = org1[0] - width * right1[0];
10277         vert[ 4] = org1[1] - width * right1[1];
10278         vert[ 5] = org1[2] - width * right1[2];
10279         vert[ 6] = org2[0] - width * right2[0];
10280         vert[ 7] = org2[1] - width * right2[1];
10281         vert[ 8] = org2[2] - width * right2[2];
10282         vert[ 9] = org2[0] + width * right2[0];
10283         vert[10] = org2[1] + width * right2[1];
10284         vert[11] = org2[2] + width * right2[2];
10285 }
10286
10287 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)
10288 {
10289         vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
10290         vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
10291         vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
10292         vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
10293         vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
10294         vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
10295         vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
10296         vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
10297         vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
10298         vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
10299         vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
10300         vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
10301 }
10302
10303 int R_Mesh_AddVertex(rmesh_t *mesh, float x, float y, float z)
10304 {
10305         int i;
10306         float *vertex3f;
10307         float v[3];
10308         VectorSet(v, x, y, z);
10309         for (i = 0, vertex3f = mesh->vertex3f;i < mesh->numvertices;i++, vertex3f += 3)
10310                 if (VectorDistance2(v, vertex3f) < mesh->epsilon2)
10311                         break;
10312         if (i == mesh->numvertices)
10313         {
10314                 if (mesh->numvertices < mesh->maxvertices)
10315                 {
10316                         VectorCopy(v, vertex3f);
10317                         mesh->numvertices++;
10318                 }
10319                 return mesh->numvertices;
10320         }
10321         else
10322                 return i;
10323 }
10324
10325 void R_Mesh_AddPolygon3f(rmesh_t *mesh, int numvertices, float *vertex3f)
10326 {
10327         int i;
10328         int *e, element[3];
10329         element[0] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
10330         element[1] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
10331         e = mesh->element3i + mesh->numtriangles * 3;
10332         for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
10333         {
10334                 element[2] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);
10335                 if (mesh->numtriangles < mesh->maxtriangles)
10336                 {
10337                         *e++ = element[0];
10338                         *e++ = element[1];
10339                         *e++ = element[2];
10340                         mesh->numtriangles++;
10341                 }
10342                 element[1] = element[2];
10343         }
10344 }
10345
10346 void R_Mesh_AddPolygon3d(rmesh_t *mesh, int numvertices, double *vertex3d)
10347 {
10348         int i;
10349         int *e, element[3];
10350         element[0] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
10351         element[1] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
10352         e = mesh->element3i + mesh->numtriangles * 3;
10353         for (i = 0;i < numvertices - 2;i++, vertex3d += 3)
10354         {
10355                 element[2] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);
10356                 if (mesh->numtriangles < mesh->maxtriangles)
10357                 {
10358                         *e++ = element[0];
10359                         *e++ = element[1];
10360                         *e++ = element[2];
10361                         mesh->numtriangles++;
10362                 }
10363                 element[1] = element[2];
10364         }
10365 }
10366
10367 #define R_MESH_PLANE_DIST_EPSILON (1.0 / 32.0)
10368 void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes)
10369 {
10370         int planenum, planenum2;
10371         int w;
10372         int tempnumpoints;
10373         mplane_t *plane, *plane2;
10374         double maxdist;
10375         double temppoints[2][256*3];
10376         // figure out how large a bounding box we need to properly compute this brush
10377         maxdist = 0;
10378         for (w = 0;w < numplanes;w++)
10379                 maxdist = max(maxdist, fabs(planes[w].dist));
10380         // now make it large enough to enclose the entire brush, and round it off to a reasonable multiple of 1024
10381         maxdist = floor(maxdist * (4.0 / 1024.0) + 1) * 1024.0;
10382         for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
10383         {
10384                 w = 0;
10385                 tempnumpoints = 4;
10386                 PolygonD_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, maxdist);
10387                 for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
10388                 {
10389                         if (planenum2 == planenum)
10390                                 continue;
10391                         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);
10392                         w = !w;
10393                 }
10394                 if (tempnumpoints < 3)
10395                         continue;
10396                 // generate elements forming a triangle fan for this polygon
10397                 R_Mesh_AddPolygon3d(mesh, tempnumpoints, temppoints[w]);
10398         }
10399 }
10400
10401 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)
10402 {
10403         texturelayer_t *layer;
10404         layer = t->currentlayers + t->currentnumlayers++;
10405         layer->type = type;
10406         layer->depthmask = depthmask;
10407         layer->blendfunc1 = blendfunc1;
10408         layer->blendfunc2 = blendfunc2;
10409         layer->texture = texture;
10410         layer->texmatrix = *matrix;
10411         layer->color[0] = r;
10412         layer->color[1] = g;
10413         layer->color[2] = b;
10414         layer->color[3] = a;
10415 }
10416
10417 static qboolean R_TestQ3WaveFunc(q3wavefunc_t func, const float *parms)
10418 {
10419         if(parms[0] == 0 && parms[1] == 0)
10420                 return false;
10421         if(func >> Q3WAVEFUNC_USER_SHIFT) // assumes rsurface to be set!
10422                 if(rsurface.userwavefunc_param[bound(0, (func >> Q3WAVEFUNC_USER_SHIFT) - 1, Q3WAVEFUNC_USER_COUNT)] == 0)
10423                         return false;
10424         return true;
10425 }
10426
10427 static float R_EvaluateQ3WaveFunc(q3wavefunc_t func, const float *parms)
10428 {
10429         double index, f;
10430         index = parms[2] + r_refdef.scene.time * parms[3];
10431         index -= floor(index);
10432         switch (func & ((1 << Q3WAVEFUNC_USER_SHIFT) - 1))
10433         {
10434         default:
10435         case Q3WAVEFUNC_NONE:
10436         case Q3WAVEFUNC_NOISE:
10437         case Q3WAVEFUNC_COUNT:
10438                 f = 0;
10439                 break;
10440         case Q3WAVEFUNC_SIN: f = sin(index * M_PI * 2);break;
10441         case Q3WAVEFUNC_SQUARE: f = index < 0.5 ? 1 : -1;break;
10442         case Q3WAVEFUNC_SAWTOOTH: f = index;break;
10443         case Q3WAVEFUNC_INVERSESAWTOOTH: f = 1 - index;break;
10444         case Q3WAVEFUNC_TRIANGLE:
10445                 index *= 4;
10446                 f = index - floor(index);
10447                 if (index < 1)
10448                         f = f;
10449                 else if (index < 2)
10450                         f = 1 - f;
10451                 else if (index < 3)
10452                         f = -f;
10453                 else
10454                         f = -(1 - f);
10455                 break;
10456         }
10457         f = parms[0] + parms[1] * f;
10458         if(func >> Q3WAVEFUNC_USER_SHIFT) // assumes rsurface to be set!
10459                 f *= rsurface.userwavefunc_param[bound(0, (func >> Q3WAVEFUNC_USER_SHIFT) - 1, Q3WAVEFUNC_USER_COUNT)];
10460         return (float) f;
10461 }
10462
10463 void R_tcMod_ApplyToMatrix(matrix4x4_t *texmatrix, q3shaderinfo_layer_tcmod_t *tcmod, int currentmaterialflags)
10464 {
10465         int w, h, idx;
10466         float f;
10467         float tcmat[12];
10468         matrix4x4_t matrix, temp;
10469         switch(tcmod->tcmod)
10470         {
10471                 case Q3TCMOD_COUNT:
10472                 case Q3TCMOD_NONE:
10473                         if (currentmaterialflags & MATERIALFLAG_WATERSCROLL)
10474                                 matrix = r_waterscrollmatrix;
10475                         else
10476                                 matrix = identitymatrix;
10477                         break;
10478                 case Q3TCMOD_ENTITYTRANSLATE:
10479                         // this is used in Q3 to allow the gamecode to control texcoord
10480                         // scrolling on the entity, which is not supported in darkplaces yet.
10481                         Matrix4x4_CreateTranslate(&matrix, 0, 0, 0);
10482                         break;
10483                 case Q3TCMOD_ROTATE:
10484                         Matrix4x4_CreateTranslate(&matrix, 0.5, 0.5, 0);
10485                         Matrix4x4_ConcatRotate(&matrix, tcmod->parms[0] * r_refdef.scene.time, 0, 0, 1);
10486                         Matrix4x4_ConcatTranslate(&matrix, -0.5, -0.5, 0);
10487                         break;
10488                 case Q3TCMOD_SCALE:
10489                         Matrix4x4_CreateScale3(&matrix, tcmod->parms[0], tcmod->parms[1], 1);
10490                         break;
10491                 case Q3TCMOD_SCROLL:
10492                         Matrix4x4_CreateTranslate(&matrix, tcmod->parms[0] * r_refdef.scene.time, tcmod->parms[1] * r_refdef.scene.time, 0);
10493                         break;
10494                 case Q3TCMOD_PAGE: // poor man's animmap (to store animations into a single file, useful for HTTP downloaded textures)
10495                         w = (int) tcmod->parms[0];
10496                         h = (int) tcmod->parms[1];
10497                         f = r_refdef.scene.time / (tcmod->parms[2] * w * h);
10498                         f = f - floor(f);
10499                         idx = (int) floor(f * w * h);
10500                         Matrix4x4_CreateTranslate(&matrix, (idx % w) / tcmod->parms[0], (idx / w) / tcmod->parms[1], 0);
10501                         break;
10502                 case Q3TCMOD_STRETCH:
10503                         f = 1.0f / R_EvaluateQ3WaveFunc(tcmod->wavefunc, tcmod->waveparms);
10504                         Matrix4x4_CreateFromQuakeEntity(&matrix, 0.5f * (1 - f), 0.5 * (1 - f), 0, 0, 0, 0, f);
10505                         break;
10506                 case Q3TCMOD_TRANSFORM:
10507                         VectorSet(tcmat +  0, tcmod->parms[0], tcmod->parms[1], 0);
10508                         VectorSet(tcmat +  3, tcmod->parms[2], tcmod->parms[3], 0);
10509                         VectorSet(tcmat +  6, 0                   , 0                , 1);
10510                         VectorSet(tcmat +  9, tcmod->parms[4], tcmod->parms[5], 0);
10511                         Matrix4x4_FromArray12FloatGL(&matrix, tcmat);
10512                         break;
10513                 case Q3TCMOD_TURBULENT:
10514                         // this is handled in the RSurf_PrepareVertices function
10515                         matrix = identitymatrix;
10516                         break;
10517         }
10518         temp = *texmatrix;
10519         Matrix4x4_Concat(texmatrix, &matrix, &temp);
10520 }
10521
10522 void R_LoadQWSkin(r_qwskincache_t *cache, const char *skinname)
10523 {
10524         int textureflags = (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_PICMIP | TEXF_COMPRESS;
10525         char name[MAX_QPATH];
10526         skinframe_t *skinframe;
10527         unsigned char pixels[296*194];
10528         strlcpy(cache->name, skinname, sizeof(cache->name));
10529         dpsnprintf(name, sizeof(name), "skins/%s.pcx", cache->name);
10530         if (developer_loading.integer)
10531                 Con_Printf("loading %s\n", name);
10532         skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
10533         if (!skinframe || !skinframe->base)
10534         {
10535                 unsigned char *f;
10536                 fs_offset_t filesize;
10537                 skinframe = NULL;
10538                 f = FS_LoadFile(name, tempmempool, true, &filesize);
10539                 if (f)
10540                 {
10541                         if (LoadPCX_QWSkin(f, (int)filesize, pixels, 296, 194))
10542                                 skinframe = R_SkinFrame_LoadInternalQuake(name, textureflags, true, r_fullbrights.integer, pixels, image_width, image_height);
10543                         Mem_Free(f);
10544                 }
10545         }
10546         cache->skinframe = skinframe;
10547 }
10548
10549 texture_t *R_GetCurrentTexture(texture_t *t)
10550 {
10551         int i;
10552         const entity_render_t *ent = rsurface.entity;
10553         dp_model_t *model = ent->model;
10554         q3shaderinfo_layer_tcmod_t *tcmod;
10555
10556         if (t->update_lastrenderframe == r_textureframe && t->update_lastrenderentity == (void *)ent)
10557                 return t->currentframe;
10558         t->update_lastrenderframe = r_textureframe;
10559         t->update_lastrenderentity = (void *)ent;
10560
10561         if(ent && ent->entitynumber >= MAX_EDICTS && ent->entitynumber < 2 * MAX_EDICTS)
10562                 t->camera_entity = ent->entitynumber;
10563         else
10564                 t->camera_entity = 0;
10565
10566         // switch to an alternate material if this is a q1bsp animated material
10567         {
10568                 texture_t *texture = t;
10569                 int s = rsurface.ent_skinnum;
10570                 if ((unsigned int)s >= (unsigned int)model->numskins)
10571                         s = 0;
10572                 if (model->skinscenes)
10573                 {
10574                         if (model->skinscenes[s].framecount > 1)
10575                                 s = model->skinscenes[s].firstframe + (unsigned int) (r_refdef.scene.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
10576                         else
10577                                 s = model->skinscenes[s].firstframe;
10578                 }
10579                 if (s > 0)
10580                         t = t + s * model->num_surfaces;
10581                 if (t->animated)
10582                 {
10583                         // use an alternate animation if the entity's frame is not 0,
10584                         // and only if the texture has an alternate animation
10585                         if (rsurface.ent_alttextures && t->anim_total[1])
10586                                 t = t->anim_frames[1][(t->anim_total[1] >= 2) ? ((int)(r_refdef.scene.time * 5.0f) % t->anim_total[1]) : 0];
10587                         else
10588                                 t = t->anim_frames[0][(t->anim_total[0] >= 2) ? ((int)(r_refdef.scene.time * 5.0f) % t->anim_total[0]) : 0];
10589                 }
10590                 texture->currentframe = t;
10591         }
10592
10593         // update currentskinframe to be a qw skin or animation frame
10594         if (rsurface.ent_qwskin >= 0)
10595         {
10596                 i = rsurface.ent_qwskin;
10597                 if (!r_qwskincache || r_qwskincache_size != cl.maxclients)
10598                 {
10599                         r_qwskincache_size = cl.maxclients;
10600                         if (r_qwskincache)
10601                                 Mem_Free(r_qwskincache);
10602                         r_qwskincache = (r_qwskincache_t *)Mem_Alloc(r_main_mempool, sizeof(*r_qwskincache) * r_qwskincache_size);
10603                 }
10604                 if (strcmp(r_qwskincache[i].name, cl.scores[i].qw_skin))
10605                         R_LoadQWSkin(&r_qwskincache[i], cl.scores[i].qw_skin);
10606                 t->currentskinframe = r_qwskincache[i].skinframe;
10607                 if (t->currentskinframe == NULL)
10608                         t->currentskinframe = t->skinframes[(unsigned int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes];
10609         }
10610         else if (t->numskinframes >= 2)
10611                 t->currentskinframe = t->skinframes[(unsigned int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes];
10612         if (t->backgroundnumskinframes >= 2)
10613                 t->backgroundcurrentskinframe = t->backgroundskinframes[(unsigned int)(t->backgroundskinframerate * (cl.time - rsurface.ent_shadertime)) % t->backgroundnumskinframes];
10614
10615         t->currentmaterialflags = t->basematerialflags;
10616         t->currentalpha = rsurface.colormod[3];
10617         if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_novis.integer))
10618                 t->currentalpha *= r_wateralpha.value;
10619         if(t->basematerialflags & MATERIALFLAG_WATERSHADER && r_waterstate.enabled && !r_refdef.view.isoverlay)
10620                 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW; // we apply wateralpha later
10621         if(!r_waterstate.enabled || r_refdef.view.isoverlay)
10622                 t->currentmaterialflags &= ~(MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA);
10623         if (!(rsurface.ent_flags & RENDER_LIGHT))
10624                 t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
10625         else if (FAKELIGHT_ENABLED)
10626         {
10627                         // no modellight if using fakelight for the map
10628         }
10629         else if (rsurface.modeltexcoordlightmap2f == NULL && !(t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
10630         {
10631                 // pick a model lighting mode
10632                 if (VectorLength2(rsurface.modellight_diffuse) >= (1.0f / 256.0f))
10633                         t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL;
10634                 else
10635                         t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT;
10636         }
10637         if (rsurface.ent_flags & RENDER_ADDITIVE)
10638                 t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
10639         else if (t->currentalpha < 1)
10640                 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
10641         if (rsurface.ent_flags & RENDER_DOUBLESIDED)
10642                 t->currentmaterialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_NOCULLFACE;
10643         if (rsurface.ent_flags & (RENDER_NODEPTHTEST | RENDER_VIEWMODEL))
10644                 t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
10645         if (t->backgroundnumskinframes)
10646                 t->currentmaterialflags |= MATERIALFLAG_VERTEXTEXTUREBLEND;
10647         if (t->currentmaterialflags & MATERIALFLAG_BLENDED)
10648         {
10649                 if (t->currentmaterialflags & (MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER | MATERIALFLAG_CAMERA))
10650                         t->currentmaterialflags &= ~MATERIALFLAG_BLENDED;
10651         }
10652         else
10653                 t->currentmaterialflags &= ~(MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER | MATERIALFLAG_CAMERA);
10654         if ((t->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST)) == MATERIALFLAG_BLENDED && r_transparentdepthmasking.integer && !(t->basematerialflags & MATERIALFLAG_BLENDED))
10655                 t->currentmaterialflags |= MATERIALFLAG_TRANSDEPTH;
10656
10657         // there is no tcmod
10658         if (t->currentmaterialflags & MATERIALFLAG_WATERSCROLL)
10659         {
10660                 t->currenttexmatrix = r_waterscrollmatrix;
10661                 t->currentbackgroundtexmatrix = r_waterscrollmatrix;
10662         }
10663         else if (!(t->currentmaterialflags & MATERIALFLAG_CUSTOMSURFACE))
10664         {
10665                 Matrix4x4_CreateIdentity(&t->currenttexmatrix);
10666                 Matrix4x4_CreateIdentity(&t->currentbackgroundtexmatrix);
10667         }
10668
10669         for (i = 0, tcmod = t->tcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
10670                 R_tcMod_ApplyToMatrix(&t->currenttexmatrix, tcmod, t->currentmaterialflags);
10671         for (i = 0, tcmod = t->backgroundtcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
10672                 R_tcMod_ApplyToMatrix(&t->currentbackgroundtexmatrix, tcmod, t->currentmaterialflags);
10673
10674         t->colormapping = VectorLength2(rsurface.colormap_pantscolor) + VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f);
10675         if (t->currentskinframe->qpixels)
10676                 R_SkinFrame_GenerateTexturesFromQPixels(t->currentskinframe, t->colormapping);
10677         t->basetexture = (!t->colormapping && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
10678         if (!t->basetexture)
10679                 t->basetexture = r_texture_notexture;
10680         t->pantstexture = t->colormapping ? t->currentskinframe->pants : NULL;
10681         t->shirttexture = t->colormapping ? t->currentskinframe->shirt : NULL;
10682         t->nmaptexture = t->currentskinframe->nmap;
10683         if (!t->nmaptexture)
10684                 t->nmaptexture = r_texture_blanknormalmap;
10685         t->glosstexture = r_texture_black;
10686         t->glowtexture = t->currentskinframe->glow;
10687         t->fogtexture = t->currentskinframe->fog;
10688         t->reflectmasktexture = t->currentskinframe->reflect;
10689         if (t->backgroundnumskinframes)
10690         {
10691                 t->backgroundbasetexture = (!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base;
10692                 t->backgroundnmaptexture = t->backgroundcurrentskinframe->nmap;
10693                 t->backgroundglosstexture = r_texture_black;
10694                 t->backgroundglowtexture = t->backgroundcurrentskinframe->glow;
10695                 if (!t->backgroundnmaptexture)
10696                         t->backgroundnmaptexture = r_texture_blanknormalmap;
10697         }
10698         else
10699         {
10700                 t->backgroundbasetexture = r_texture_white;
10701                 t->backgroundnmaptexture = r_texture_blanknormalmap;
10702                 t->backgroundglosstexture = r_texture_black;
10703                 t->backgroundglowtexture = NULL;
10704         }
10705         t->specularpower = r_shadow_glossexponent.value;
10706         // TODO: store reference values for these in the texture?
10707         t->specularscale = 0;
10708         if (r_shadow_gloss.integer > 0)
10709         {
10710                 if (t->currentskinframe->gloss || (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss))
10711                 {
10712                         if (r_shadow_glossintensity.value > 0)
10713                         {
10714                                 t->glosstexture = t->currentskinframe->gloss ? t->currentskinframe->gloss : r_texture_white;
10715                                 t->backgroundglosstexture = (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss) ? t->backgroundcurrentskinframe->gloss : r_texture_white;
10716                                 t->specularscale = r_shadow_glossintensity.value;
10717                         }
10718                 }
10719                 else if (r_shadow_gloss.integer >= 2 && r_shadow_gloss2intensity.value > 0)
10720                 {
10721                         t->glosstexture = r_texture_white;
10722                         t->backgroundglosstexture = r_texture_white;
10723                         t->specularscale = r_shadow_gloss2intensity.value;
10724                         t->specularpower = r_shadow_gloss2exponent.value;
10725                 }
10726         }
10727         t->specularscale *= t->specularscalemod;
10728         t->specularpower *= t->specularpowermod;
10729
10730         // lightmaps mode looks bad with dlights using actual texturing, so turn
10731         // off the colormap and glossmap, but leave the normalmap on as it still
10732         // accurately represents the shading involved
10733         if (gl_lightmaps.integer)
10734         {
10735                 t->basetexture = r_texture_grey128;
10736                 t->pantstexture = r_texture_black;
10737                 t->shirttexture = r_texture_black;
10738                 t->nmaptexture = r_texture_blanknormalmap;
10739                 t->glosstexture = r_texture_black;
10740                 t->glowtexture = NULL;
10741                 t->fogtexture = NULL;
10742                 t->reflectmasktexture = NULL;
10743                 t->backgroundbasetexture = NULL;
10744                 t->backgroundnmaptexture = r_texture_blanknormalmap;
10745                 t->backgroundglosstexture = r_texture_black;
10746                 t->backgroundglowtexture = NULL;
10747                 t->specularscale = 0;
10748                 t->currentmaterialflags = MATERIALFLAG_WALL | (t->currentmaterialflags & (MATERIALFLAG_NOCULLFACE | MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SHORTDEPTHRANGE));
10749         }
10750
10751         Vector4Set(t->lightmapcolor, rsurface.colormod[0], rsurface.colormod[1], rsurface.colormod[2], t->currentalpha);
10752         VectorClear(t->dlightcolor);
10753         t->currentnumlayers = 0;
10754         if (t->currentmaterialflags & MATERIALFLAG_WALL)
10755         {
10756                 int blendfunc1, blendfunc2;
10757                 qboolean depthmask;
10758                 if (t->currentmaterialflags & MATERIALFLAG_ADD)
10759                 {
10760                         blendfunc1 = GL_SRC_ALPHA;
10761                         blendfunc2 = GL_ONE;
10762                 }
10763                 else if (t->currentmaterialflags & MATERIALFLAG_ALPHA)
10764                 {
10765                         blendfunc1 = GL_SRC_ALPHA;
10766                         blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
10767                 }
10768                 else if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
10769                 {
10770                         blendfunc1 = t->customblendfunc[0];
10771                         blendfunc2 = t->customblendfunc[1];
10772                 }
10773                 else
10774                 {
10775                         blendfunc1 = GL_ONE;
10776                         blendfunc2 = GL_ZERO;
10777                 }
10778                 // don't colormod evilblend textures
10779                 if(!R_BlendFuncAllowsColormod(blendfunc1, blendfunc2))
10780                         VectorSet(t->lightmapcolor, 1, 1, 1);
10781                 depthmask = !(t->currentmaterialflags & MATERIALFLAG_BLENDED);
10782                 if (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
10783                 {
10784                         // fullbright is not affected by r_refdef.lightmapintensity
10785                         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]);
10786                         if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
10787                                 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]);
10788                         if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
10789                                 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]);
10790                 }
10791                 else
10792                 {
10793                         vec3_t ambientcolor;
10794                         float colorscale;
10795                         // set the color tint used for lights affecting this surface
10796                         VectorSet(t->dlightcolor, t->lightmapcolor[0] * t->lightmapcolor[3], t->lightmapcolor[1] * t->lightmapcolor[3], t->lightmapcolor[2] * t->lightmapcolor[3]);
10797                         colorscale = 2;
10798                         // q3bsp has no lightmap updates, so the lightstylevalue that
10799                         // would normally be baked into the lightmap must be
10800                         // applied to the color
10801                         // FIXME: r_glsl 1 rendering doesn't support overbright lightstyles with this (the default light style is not overbright)
10802                         if (model->type == mod_brushq3)
10803                                 colorscale *= r_refdef.scene.rtlightstylevalue[0];
10804                         colorscale *= r_refdef.lightmapintensity;
10805                         VectorScale(t->lightmapcolor, r_refdef.scene.ambient, ambientcolor);
10806                         VectorScale(t->lightmapcolor, colorscale, t->lightmapcolor);
10807                         // basic lit geometry
10808                         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]);
10809                         // add pants/shirt if needed
10810                         if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
10811                                 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]);
10812                         if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
10813                                 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]);
10814                         // now add ambient passes if needed
10815                         if (VectorLength2(ambientcolor) >= (1.0f/1048576.0f))
10816                         {
10817                                 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]);
10818                                 if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
10819                                         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]);
10820                                 if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
10821                                         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]);
10822                         }
10823                 }
10824                 if (t->glowtexture != NULL && !gl_lightmaps.integer)
10825                         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]);
10826                 if (r_refdef.fogenabled && !(t->currentmaterialflags & MATERIALFLAG_ADD))
10827                 {
10828                         // if this is opaque use alpha blend which will darken the earlier
10829                         // passes cheaply.
10830                         //
10831                         // if this is an alpha blended material, all the earlier passes
10832                         // were darkened by fog already, so we only need to add the fog
10833                         // color ontop through the fog mask texture
10834                         //
10835                         // if this is an additive blended material, all the earlier passes
10836                         // were darkened by fog already, and we should not add fog color
10837                         // (because the background was not darkened, there is no fog color
10838                         // that was lost behind it).
10839                         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]);
10840                 }
10841         }
10842
10843         return t->currentframe;
10844 }
10845
10846 rsurfacestate_t rsurface;
10847
10848 void R_Mesh_ResizeArrays(int newvertices)
10849 {
10850         unsigned char *base;
10851         size_t size;
10852         if (rsurface.array_size >= newvertices)
10853                 return;
10854         if (rsurface.array_base)
10855                 Mem_Free(rsurface.array_base);
10856         rsurface.array_size = (newvertices + 1023) & ~1023;
10857         size = 0;
10858         size += rsurface.array_size * sizeof(*rsurface.array_modelvertexmesh);
10859         size += rsurface.array_size * sizeof(*rsurface.array_batchvertexmesh);
10860         size += rsurface.array_size * sizeof(*rsurface.array_modelvertexposition);
10861         size += rsurface.array_size * sizeof(*rsurface.array_batchvertexposition);
10862         size += rsurface.array_size * sizeof(float[3]);
10863         size += rsurface.array_size * sizeof(float[3]);
10864         size += rsurface.array_size * sizeof(float[3]);
10865         size += rsurface.array_size * sizeof(float[3]);
10866         size += rsurface.array_size * sizeof(float[3]);
10867         size += rsurface.array_size * sizeof(float[3]);
10868         size += rsurface.array_size * sizeof(float[3]);
10869         size += rsurface.array_size * sizeof(float[3]);
10870         size += rsurface.array_size * sizeof(float[4]);
10871         size += rsurface.array_size * sizeof(float[2]);
10872         size += rsurface.array_size * sizeof(float[2]);
10873         size += rsurface.array_size * sizeof(float[4]);
10874         size += rsurface.array_size * sizeof(int[3]);
10875         size += rsurface.array_size * sizeof(unsigned short[3]);
10876         rsurface.array_base = base = (unsigned char *)Mem_Alloc(r_main_mempool, size);
10877         rsurface.array_modelvertexmesh         = (r_vertexmesh_t     *)base;base += rsurface.array_size * sizeof(*rsurface.array_modelvertexmesh);
10878         rsurface.array_batchvertexmesh         = (r_vertexmesh_t     *)base;base += rsurface.array_size * sizeof(*rsurface.array_batchvertexmesh);
10879         rsurface.array_modelvertexposition     = (r_vertexposition_t *)base;base += rsurface.array_size * sizeof(*rsurface.array_modelvertexposition);
10880         rsurface.array_batchvertexposition     = (r_vertexposition_t *)base;base += rsurface.array_size * sizeof(*rsurface.array_batchvertexposition);
10881         rsurface.array_modelvertex3f           = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10882         rsurface.array_modelsvector3f          = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10883         rsurface.array_modeltvector3f          = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10884         rsurface.array_modelnormal3f           = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10885         rsurface.array_batchvertex3f           = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10886         rsurface.array_batchsvector3f          = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10887         rsurface.array_batchtvector3f          = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10888         rsurface.array_batchnormal3f           = (float              *)base;base += rsurface.array_size * sizeof(float[3]);
10889         rsurface.array_batchlightmapcolor4f    = (float              *)base;base += rsurface.array_size * sizeof(float[4]);
10890         rsurface.array_batchtexcoordtexture2f  = (float              *)base;base += rsurface.array_size * sizeof(float[2]);
10891         rsurface.array_batchtexcoordlightmap2f = (float              *)base;base += rsurface.array_size * sizeof(float[2]);
10892         rsurface.array_passcolor4f             = (float              *)base;base += rsurface.array_size * sizeof(float[4]);
10893         rsurface.array_batchelement3i          = (int                *)base;base += rsurface.array_size * sizeof(int[3]);
10894         rsurface.array_batchelement3s          = (unsigned short     *)base;base += rsurface.array_size * sizeof(unsigned short[3]);
10895 }
10896
10897 void RSurf_ActiveWorldEntity(void)
10898 {
10899         int newvertices;
10900         dp_model_t *model = r_refdef.scene.worldmodel;
10901         //if (rsurface.entity == r_refdef.scene.worldentity)
10902         //      return;
10903         rsurface.entity = r_refdef.scene.worldentity;
10904         rsurface.skeleton = NULL;
10905         memset(rsurface.userwavefunc_param, 0, sizeof(rsurface.userwavefunc_param));
10906         rsurface.ent_skinnum = 0;
10907         rsurface.ent_qwskin = -1;
10908         rsurface.ent_shadertime = 0;
10909         rsurface.ent_flags = r_refdef.scene.worldentity->flags;
10910         newvertices = max(model->surfmesh.num_vertices, model->surfmesh.num_triangles);
10911         if (rsurface.array_size < newvertices)
10912                 R_Mesh_ResizeArrays(newvertices);
10913         rsurface.matrix = identitymatrix;
10914         rsurface.inversematrix = identitymatrix;
10915         rsurface.matrixscale = 1;
10916         rsurface.inversematrixscale = 1;
10917         R_EntityMatrix(&identitymatrix);
10918         VectorCopy(r_refdef.view.origin, rsurface.localvieworigin);
10919         Vector4Copy(r_refdef.fogplane, rsurface.fogplane);
10920         rsurface.fograngerecip = r_refdef.fograngerecip;
10921         rsurface.fogheightfade = r_refdef.fogheightfade;
10922         rsurface.fogplaneviewdist = r_refdef.fogplaneviewdist;
10923         rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
10924         VectorSet(rsurface.modellight_ambient, 0, 0, 0);
10925         VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
10926         VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
10927         VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
10928         VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
10929         VectorSet(rsurface.colormod, r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale);
10930         rsurface.colormod[3] = 1;
10931         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);
10932         memset(rsurface.frameblend, 0, sizeof(rsurface.frameblend));
10933         rsurface.frameblend[0].lerp = 1;
10934         rsurface.ent_alttextures = false;
10935         rsurface.basepolygonfactor = r_refdef.polygonfactor;
10936         rsurface.basepolygonoffset = r_refdef.polygonoffset;
10937         rsurface.modelvertex3f  = model->surfmesh.data_vertex3f;
10938         rsurface.modelvertex3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
10939         rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
10940         rsurface.modelsvector3f = model->surfmesh.data_svector3f;
10941         rsurface.modelsvector3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
10942         rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
10943         rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
10944         rsurface.modeltvector3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
10945         rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
10946         rsurface.modelnormal3f  = model->surfmesh.data_normal3f;
10947         rsurface.modelnormal3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
10948         rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
10949         rsurface.modellightmapcolor4f  = model->surfmesh.data_lightmapcolor4f;
10950         rsurface.modellightmapcolor4f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
10951         rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
10952         rsurface.modeltexcoordtexture2f  = model->surfmesh.data_texcoordtexture2f;
10953         rsurface.modeltexcoordtexture2f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
10954         rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
10955         rsurface.modeltexcoordlightmap2f  = model->surfmesh.data_texcoordlightmap2f;
10956         rsurface.modeltexcoordlightmap2f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
10957         rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
10958         rsurface.modelelement3i = model->surfmesh.data_element3i;
10959         rsurface.modelelement3i_indexbuffer = model->surfmesh.data_element3i_indexbuffer;
10960         rsurface.modelelement3i_bufferoffset = model->surfmesh.data_element3i_bufferoffset;
10961         rsurface.modelelement3s = model->surfmesh.data_element3s;
10962         rsurface.modelelement3s_indexbuffer = model->surfmesh.data_element3s_indexbuffer;
10963         rsurface.modelelement3s_bufferoffset = model->surfmesh.data_element3s_bufferoffset;
10964         rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
10965         rsurface.modelnumvertices = model->surfmesh.num_vertices;
10966         rsurface.modelnumtriangles = model->surfmesh.num_triangles;
10967         rsurface.modelsurfaces = model->data_surfaces;
10968         rsurface.modelvertexmesh = model->surfmesh.vertexmesh;
10969         rsurface.modelvertexmeshbuffer = model->surfmesh.vertexmeshbuffer;
10970         rsurface.modelvertexposition = model->surfmesh.vertexposition;
10971         rsurface.modelvertexpositionbuffer = model->surfmesh.vertexpositionbuffer;
10972         rsurface.modelgeneratedvertex = false;
10973         rsurface.batchgeneratedvertex = false;
10974         rsurface.batchfirstvertex = 0;
10975         rsurface.batchnumvertices = 0;
10976         rsurface.batchfirsttriangle = 0;
10977         rsurface.batchnumtriangles = 0;
10978         rsurface.batchvertex3f  = NULL;
10979         rsurface.batchvertex3f_vertexbuffer = NULL;
10980         rsurface.batchvertex3f_bufferoffset = 0;
10981         rsurface.batchsvector3f = NULL;
10982         rsurface.batchsvector3f_vertexbuffer = NULL;
10983         rsurface.batchsvector3f_bufferoffset = 0;
10984         rsurface.batchtvector3f = NULL;
10985         rsurface.batchtvector3f_vertexbuffer = NULL;
10986         rsurface.batchtvector3f_bufferoffset = 0;
10987         rsurface.batchnormal3f  = NULL;
10988         rsurface.batchnormal3f_vertexbuffer = NULL;
10989         rsurface.batchnormal3f_bufferoffset = 0;
10990         rsurface.batchlightmapcolor4f = NULL;
10991         rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
10992         rsurface.batchlightmapcolor4f_bufferoffset = 0;
10993         rsurface.batchtexcoordtexture2f = NULL;
10994         rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
10995         rsurface.batchtexcoordtexture2f_bufferoffset = 0;
10996         rsurface.batchtexcoordlightmap2f = NULL;
10997         rsurface.batchtexcoordlightmap2f_vertexbuffer = NULL;
10998         rsurface.batchtexcoordlightmap2f_bufferoffset = 0;
10999         rsurface.batchvertexmesh = NULL;
11000         rsurface.batchvertexmeshbuffer = NULL;
11001         rsurface.batchvertexposition = NULL;
11002         rsurface.batchvertexpositionbuffer = NULL;
11003         rsurface.batchelement3i = NULL;
11004         rsurface.batchelement3i_indexbuffer = NULL;
11005         rsurface.batchelement3i_bufferoffset = 0;
11006         rsurface.batchelement3s = NULL;
11007         rsurface.batchelement3s_indexbuffer = NULL;
11008         rsurface.batchelement3s_bufferoffset = 0;
11009         rsurface.passcolor4f = NULL;
11010         rsurface.passcolor4f_vertexbuffer = NULL;
11011         rsurface.passcolor4f_bufferoffset = 0;
11012 }
11013
11014 void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents, qboolean prepass)
11015 {
11016         int newvertices;
11017         dp_model_t *model = ent->model;
11018         //if (rsurface.entity == ent && (!model->surfmesh.isanimated || (!wantnormals && !wanttangents)))
11019         //      return;
11020         rsurface.entity = (entity_render_t *)ent;
11021         rsurface.skeleton = ent->skeleton;
11022         memcpy(rsurface.userwavefunc_param, ent->userwavefunc_param, sizeof(rsurface.userwavefunc_param));
11023         rsurface.ent_skinnum = ent->skinnum;
11024         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;
11025         rsurface.ent_shadertime = ent->shadertime;
11026         rsurface.ent_flags = ent->flags;
11027         newvertices = max(model->surfmesh.num_vertices, model->surfmesh.num_triangles);
11028         if (rsurface.array_size < newvertices)
11029                 R_Mesh_ResizeArrays(newvertices);
11030         rsurface.matrix = ent->matrix;
11031         rsurface.inversematrix = ent->inversematrix;
11032         rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
11033         rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
11034         R_EntityMatrix(&rsurface.matrix);
11035         Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
11036         Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
11037         rsurface.fogplaneviewdist *= rsurface.inversematrixscale;
11038         rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
11039         rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
11040         rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
11041         VectorCopy(ent->modellight_ambient, rsurface.modellight_ambient);
11042         VectorCopy(ent->modellight_diffuse, rsurface.modellight_diffuse);
11043         VectorCopy(ent->modellight_lightdir, rsurface.modellight_lightdir);
11044         VectorCopy(ent->colormap_pantscolor, rsurface.colormap_pantscolor);
11045         VectorCopy(ent->colormap_shirtcolor, rsurface.colormap_shirtcolor);
11046         VectorScale(ent->colormod, r_refdef.view.colorscale, rsurface.colormod);
11047         rsurface.colormod[3] = ent->alpha;
11048         VectorScale(ent->glowmod, r_refdef.view.colorscale * r_hdr_glowintensity.value, rsurface.glowmod);
11049         memcpy(rsurface.frameblend, ent->frameblend, sizeof(ent->frameblend));
11050         rsurface.ent_alttextures = ent->framegroupblend[0].frame != 0;
11051         rsurface.basepolygonfactor = r_refdef.polygonfactor;
11052         rsurface.basepolygonoffset = r_refdef.polygonoffset;
11053         if (ent->model->brush.submodel && !prepass)
11054         {
11055                 rsurface.basepolygonfactor += r_polygonoffset_submodel_factor.value;
11056                 rsurface.basepolygonoffset += r_polygonoffset_submodel_offset.value;
11057         }
11058         if (model->surfmesh.isanimated && model->AnimateVertices && (rsurface.frameblend[0].lerp != 1 || rsurface.frameblend[0].subframe != 0))
11059         {
11060                 if (ent->animcache_vertex3f && !r_framedata_failed)
11061                 {
11062                         rsurface.modelvertex3f = ent->animcache_vertex3f;
11063                         rsurface.modelsvector3f = wanttangents ? ent->animcache_svector3f : NULL;
11064                         rsurface.modeltvector3f = wanttangents ? ent->animcache_tvector3f : NULL;
11065                         rsurface.modelnormal3f = wantnormals ? ent->animcache_normal3f : NULL;
11066                         rsurface.modelvertexmesh = ent->animcache_vertexmesh;
11067                         rsurface.modelvertexmeshbuffer = ent->animcache_vertexmeshbuffer;
11068                         rsurface.modelvertexposition = ent->animcache_vertexposition;
11069                         rsurface.modelvertexpositionbuffer = ent->animcache_vertexpositionbuffer;
11070                 }
11071                 else if (wanttangents)
11072                 {
11073                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
11074                         rsurface.modelsvector3f = rsurface.array_modelsvector3f;
11075                         rsurface.modeltvector3f = rsurface.array_modeltvector3f;
11076                         rsurface.modelnormal3f = rsurface.array_modelnormal3f;
11077                         model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f);
11078                         rsurface.modelvertexmesh = NULL;
11079                         rsurface.modelvertexmeshbuffer = NULL;
11080                         rsurface.modelvertexposition = NULL;
11081                         rsurface.modelvertexpositionbuffer = NULL;
11082                 }
11083                 else if (wantnormals)
11084                 {
11085                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
11086                         rsurface.modelsvector3f = NULL;
11087                         rsurface.modeltvector3f = NULL;
11088                         rsurface.modelnormal3f = rsurface.array_modelnormal3f;
11089                         model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, NULL, NULL);
11090                         rsurface.modelvertexmesh = NULL;
11091                         rsurface.modelvertexmeshbuffer = NULL;
11092                         rsurface.modelvertexposition = NULL;
11093                         rsurface.modelvertexpositionbuffer = NULL;
11094                 }
11095                 else
11096                 {
11097                         rsurface.modelvertex3f = rsurface.array_modelvertex3f;
11098                         rsurface.modelsvector3f = NULL;
11099                         rsurface.modeltvector3f = NULL;
11100                         rsurface.modelnormal3f = NULL;
11101                         model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, NULL, NULL, NULL);
11102                         rsurface.modelvertexmesh = NULL;
11103                         rsurface.modelvertexmeshbuffer = NULL;
11104                         rsurface.modelvertexposition = NULL;
11105                         rsurface.modelvertexpositionbuffer = NULL;
11106                 }
11107                 rsurface.modelvertex3f_vertexbuffer = 0;
11108                 rsurface.modelvertex3f_bufferoffset = 0;
11109                 rsurface.modelsvector3f_vertexbuffer = 0;
11110                 rsurface.modelsvector3f_bufferoffset = 0;
11111                 rsurface.modeltvector3f_vertexbuffer = 0;
11112                 rsurface.modeltvector3f_bufferoffset = 0;
11113                 rsurface.modelnormal3f_vertexbuffer = 0;
11114                 rsurface.modelnormal3f_bufferoffset = 0;
11115                 rsurface.modelgeneratedvertex = true;
11116         }
11117         else
11118         {
11119                 rsurface.modelvertex3f  = model->surfmesh.data_vertex3f;
11120                 rsurface.modelvertex3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
11121                 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
11122                 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
11123                 rsurface.modelsvector3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
11124                 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
11125                 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
11126                 rsurface.modeltvector3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
11127                 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
11128                 rsurface.modelnormal3f  = model->surfmesh.data_normal3f;
11129                 rsurface.modelnormal3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
11130                 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
11131                 rsurface.modelvertexmesh = model->surfmesh.vertexmesh;
11132                 rsurface.modelvertexmeshbuffer = model->surfmesh.vertexmeshbuffer;
11133                 rsurface.modelvertexposition = model->surfmesh.vertexposition;
11134                 rsurface.modelvertexpositionbuffer = model->surfmesh.vertexpositionbuffer;
11135                 rsurface.modelgeneratedvertex = false;
11136         }
11137         rsurface.modellightmapcolor4f  = model->surfmesh.data_lightmapcolor4f;
11138         rsurface.modellightmapcolor4f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
11139         rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
11140         rsurface.modeltexcoordtexture2f  = model->surfmesh.data_texcoordtexture2f;
11141         rsurface.modeltexcoordtexture2f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
11142         rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
11143         rsurface.modeltexcoordlightmap2f  = model->surfmesh.data_texcoordlightmap2f;
11144         rsurface.modeltexcoordlightmap2f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
11145         rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
11146         rsurface.modelelement3i = model->surfmesh.data_element3i;
11147         rsurface.modelelement3i_indexbuffer = model->surfmesh.data_element3i_indexbuffer;
11148         rsurface.modelelement3i_bufferoffset = model->surfmesh.data_element3i_bufferoffset;
11149         rsurface.modelelement3s = model->surfmesh.data_element3s;
11150         rsurface.modelelement3s_indexbuffer = model->surfmesh.data_element3s_indexbuffer;
11151         rsurface.modelelement3s_bufferoffset = model->surfmesh.data_element3s_bufferoffset;
11152         rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
11153         rsurface.modelnumvertices = model->surfmesh.num_vertices;
11154         rsurface.modelnumtriangles = model->surfmesh.num_triangles;
11155         rsurface.modelsurfaces = model->data_surfaces;
11156         rsurface.batchgeneratedvertex = false;
11157         rsurface.batchfirstvertex = 0;
11158         rsurface.batchnumvertices = 0;
11159         rsurface.batchfirsttriangle = 0;
11160         rsurface.batchnumtriangles = 0;
11161         rsurface.batchvertex3f  = NULL;
11162         rsurface.batchvertex3f_vertexbuffer = NULL;
11163         rsurface.batchvertex3f_bufferoffset = 0;
11164         rsurface.batchsvector3f = NULL;
11165         rsurface.batchsvector3f_vertexbuffer = NULL;
11166         rsurface.batchsvector3f_bufferoffset = 0;
11167         rsurface.batchtvector3f = NULL;
11168         rsurface.batchtvector3f_vertexbuffer = NULL;
11169         rsurface.batchtvector3f_bufferoffset = 0;
11170         rsurface.batchnormal3f  = NULL;
11171         rsurface.batchnormal3f_vertexbuffer = NULL;
11172         rsurface.batchnormal3f_bufferoffset = 0;
11173         rsurface.batchlightmapcolor4f = NULL;
11174         rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
11175         rsurface.batchlightmapcolor4f_bufferoffset = 0;
11176         rsurface.batchtexcoordtexture2f = NULL;
11177         rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
11178         rsurface.batchtexcoordtexture2f_bufferoffset = 0;
11179         rsurface.batchtexcoordlightmap2f = NULL;
11180         rsurface.batchtexcoordlightmap2f_vertexbuffer = NULL;
11181         rsurface.batchtexcoordlightmap2f_bufferoffset = 0;
11182         rsurface.batchvertexmesh = NULL;
11183         rsurface.batchvertexmeshbuffer = NULL;
11184         rsurface.batchvertexposition = NULL;
11185         rsurface.batchvertexpositionbuffer = NULL;
11186         rsurface.batchelement3i = NULL;
11187         rsurface.batchelement3i_indexbuffer = NULL;
11188         rsurface.batchelement3i_bufferoffset = 0;
11189         rsurface.batchelement3s = NULL;
11190         rsurface.batchelement3s_indexbuffer = NULL;
11191         rsurface.batchelement3s_bufferoffset = 0;
11192         rsurface.passcolor4f = NULL;
11193         rsurface.passcolor4f_vertexbuffer = NULL;
11194         rsurface.passcolor4f_bufferoffset = 0;
11195 }
11196
11197 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)
11198 {
11199         int newvertices;
11200
11201         rsurface.entity = r_refdef.scene.worldentity;
11202         rsurface.skeleton = NULL;
11203         rsurface.ent_skinnum = 0;
11204         rsurface.ent_qwskin = -1;
11205         rsurface.ent_shadertime = shadertime;
11206         rsurface.ent_flags = entflags;
11207         rsurface.modelnumvertices = numvertices;
11208         rsurface.modelnumtriangles = numtriangles;
11209         newvertices = max(rsurface.modelnumvertices, rsurface.modelnumtriangles);
11210         if (rsurface.array_size < newvertices)
11211                 R_Mesh_ResizeArrays(newvertices);
11212         rsurface.matrix = *matrix;
11213         rsurface.inversematrix = *inversematrix;
11214         rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
11215         rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
11216         R_EntityMatrix(&rsurface.matrix);
11217         Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
11218         Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
11219         rsurface.fogplaneviewdist *= rsurface.inversematrixscale;
11220         rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
11221         rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
11222         rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
11223         VectorSet(rsurface.modellight_ambient, 0, 0, 0);
11224         VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
11225         VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
11226         VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
11227         VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
11228         Vector4Set(rsurface.colormod, r * r_refdef.view.colorscale, g * r_refdef.view.colorscale, b * r_refdef.view.colorscale, a);
11229         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);
11230         memset(rsurface.frameblend, 0, sizeof(rsurface.frameblend));
11231         rsurface.frameblend[0].lerp = 1;
11232         rsurface.ent_alttextures = false;
11233         rsurface.basepolygonfactor = r_refdef.polygonfactor;
11234         rsurface.basepolygonoffset = r_refdef.polygonoffset;
11235         if (wanttangents)
11236         {
11237                 rsurface.modelvertex3f = vertex3f;
11238                 rsurface.modelsvector3f = svector3f ? svector3f : rsurface.array_modelsvector3f;
11239                 rsurface.modeltvector3f = tvector3f ? tvector3f : rsurface.array_modeltvector3f;
11240                 rsurface.modelnormal3f = normal3f ? normal3f : rsurface.array_modelnormal3f;
11241         }
11242         else if (wantnormals)
11243         {
11244                 rsurface.modelvertex3f = vertex3f;
11245                 rsurface.modelsvector3f = NULL;
11246                 rsurface.modeltvector3f = NULL;
11247                 rsurface.modelnormal3f = normal3f ? normal3f : rsurface.array_modelnormal3f;
11248         }
11249         else
11250         {
11251                 rsurface.modelvertex3f = vertex3f;
11252                 rsurface.modelsvector3f = NULL;
11253                 rsurface.modeltvector3f = NULL;
11254                 rsurface.modelnormal3f = NULL;
11255         }
11256         rsurface.modelvertexmesh = NULL;
11257         rsurface.modelvertexmeshbuffer = NULL;
11258         rsurface.modelvertexposition = NULL;
11259         rsurface.modelvertexpositionbuffer = NULL;
11260         rsurface.modelvertex3f_vertexbuffer = 0;
11261         rsurface.modelvertex3f_bufferoffset = 0;
11262         rsurface.modelsvector3f_vertexbuffer = 0;
11263         rsurface.modelsvector3f_bufferoffset = 0;
11264         rsurface.modeltvector3f_vertexbuffer = 0;
11265         rsurface.modeltvector3f_bufferoffset = 0;
11266         rsurface.modelnormal3f_vertexbuffer = 0;
11267         rsurface.modelnormal3f_bufferoffset = 0;
11268         rsurface.modelgeneratedvertex = true;
11269         rsurface.modellightmapcolor4f  = color4f;
11270         rsurface.modellightmapcolor4f_vertexbuffer = 0;
11271         rsurface.modellightmapcolor4f_bufferoffset = 0;
11272         rsurface.modeltexcoordtexture2f  = texcoord2f;
11273         rsurface.modeltexcoordtexture2f_vertexbuffer = 0;
11274         rsurface.modeltexcoordtexture2f_bufferoffset = 0;
11275         rsurface.modeltexcoordlightmap2f  = NULL;
11276         rsurface.modeltexcoordlightmap2f_vertexbuffer = 0;
11277         rsurface.modeltexcoordlightmap2f_bufferoffset = 0;
11278         rsurface.modelelement3i = element3i;
11279         rsurface.modelelement3i_indexbuffer = NULL;
11280         rsurface.modelelement3i_bufferoffset = 0;
11281         rsurface.modelelement3s = element3s;
11282         rsurface.modelelement3s_indexbuffer = NULL;
11283         rsurface.modelelement3s_bufferoffset = 0;
11284         rsurface.modellightmapoffsets = NULL;
11285         rsurface.modelsurfaces = NULL;
11286         rsurface.batchgeneratedvertex = false;
11287         rsurface.batchfirstvertex = 0;
11288         rsurface.batchnumvertices = 0;
11289         rsurface.batchfirsttriangle = 0;
11290         rsurface.batchnumtriangles = 0;
11291         rsurface.batchvertex3f  = NULL;
11292         rsurface.batchvertex3f_vertexbuffer = NULL;
11293         rsurface.batchvertex3f_bufferoffset = 0;
11294         rsurface.batchsvector3f = NULL;
11295         rsurface.batchsvector3f_vertexbuffer = NULL;
11296         rsurface.batchsvector3f_bufferoffset = 0;
11297         rsurface.batchtvector3f = NULL;
11298         rsurface.batchtvector3f_vertexbuffer = NULL;
11299         rsurface.batchtvector3f_bufferoffset = 0;
11300         rsurface.batchnormal3f  = NULL;
11301         rsurface.batchnormal3f_vertexbuffer = NULL;
11302         rsurface.batchnormal3f_bufferoffset = 0;
11303         rsurface.batchlightmapcolor4f = NULL;
11304         rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
11305         rsurface.batchlightmapcolor4f_bufferoffset = 0;
11306         rsurface.batchtexcoordtexture2f = NULL;
11307         rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
11308         rsurface.batchtexcoordtexture2f_bufferoffset = 0;
11309         rsurface.batchtexcoordlightmap2f = NULL;
11310         rsurface.batchtexcoordlightmap2f_vertexbuffer = NULL;
11311         rsurface.batchtexcoordlightmap2f_bufferoffset = 0;
11312         rsurface.batchvertexmesh = NULL;
11313         rsurface.batchvertexmeshbuffer = NULL;
11314         rsurface.batchvertexposition = NULL;
11315         rsurface.batchvertexpositionbuffer = NULL;
11316         rsurface.batchelement3i = NULL;
11317         rsurface.batchelement3i_indexbuffer = NULL;
11318         rsurface.batchelement3i_bufferoffset = 0;
11319         rsurface.batchelement3s = NULL;
11320         rsurface.batchelement3s_indexbuffer = NULL;
11321         rsurface.batchelement3s_bufferoffset = 0;
11322         rsurface.passcolor4f = NULL;
11323         rsurface.passcolor4f_vertexbuffer = NULL;
11324         rsurface.passcolor4f_bufferoffset = 0;
11325
11326         if (rsurface.modelnumvertices && rsurface.modelelement3i)
11327         {
11328                 if ((wantnormals || wanttangents) && !normal3f)
11329                 {
11330                         Mod_BuildNormals(0, rsurface.modelnumvertices, rsurface.modelnumtriangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer != 0);
11331                         rsurface.modelnormal3f = rsurface.array_modelnormal3f;
11332                 }
11333                 if (wanttangents && !svector3f)
11334                 {
11335                         Mod_BuildTextureVectorsFromNormals(0, rsurface.modelnumvertices, rsurface.modelnumtriangles, rsurface.modelvertex3f, rsurface.modeltexcoordtexture2f, rsurface.modelnormal3f, rsurface.modelelement3i, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f, r_smoothnormals_areaweighting.integer != 0);
11336                         rsurface.modelsvector3f = rsurface.array_modelsvector3f;
11337                         rsurface.modeltvector3f = rsurface.array_modeltvector3f;
11338                 }
11339         }
11340 }
11341
11342 float RSurf_FogPoint(const float *v)
11343 {
11344         // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
11345         float FogPlaneViewDist = r_refdef.fogplaneviewdist;
11346         float FogPlaneVertexDist = DotProduct(r_refdef.fogplane, v) + r_refdef.fogplane[3];
11347         float FogHeightFade = r_refdef.fogheightfade;
11348         float fogfrac;
11349         unsigned int fogmasktableindex;
11350         if (r_refdef.fogplaneviewabove)
11351                 fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
11352         else
11353                 fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
11354         fogmasktableindex = (unsigned int)(VectorDistance(r_refdef.view.origin, v) * fogfrac * r_refdef.fogmasktabledistmultiplier);
11355         return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
11356 }
11357
11358 float RSurf_FogVertex(const float *v)
11359 {
11360         // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
11361         float FogPlaneViewDist = rsurface.fogplaneviewdist;
11362         float FogPlaneVertexDist = DotProduct(rsurface.fogplane, v) + rsurface.fogplane[3];
11363         float FogHeightFade = rsurface.fogheightfade;
11364         float fogfrac;
11365         unsigned int fogmasktableindex;
11366         if (r_refdef.fogplaneviewabove)
11367                 fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
11368         else
11369                 fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
11370         fogmasktableindex = (unsigned int)(VectorDistance(rsurface.localvieworigin, v) * fogfrac * rsurface.fogmasktabledistmultiplier);
11371         return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
11372 }
11373
11374 void RSurf_RenumberElements(const int *inelement3i, int *outelement3i, int numelements, int adjust)
11375 {
11376         int i;
11377         for (i = 0;i < numelements;i++)
11378                 outelement3i[i] = inelement3i[i] + adjust;
11379 }
11380
11381 static const int quadedges[6][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}};
11382 extern cvar_t gl_vbo;
11383 void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const msurface_t **texturesurfacelist)
11384 {
11385         int deformindex;
11386         int firsttriangle;
11387         int numtriangles;
11388         int firstvertex;
11389         int endvertex;
11390         int numvertices;
11391         int surfacefirsttriangle;
11392         int surfacenumtriangles;
11393         int surfacefirstvertex;
11394         int surfaceendvertex;
11395         int surfacenumvertices;
11396         int needsupdate;
11397         int i, j;
11398         qboolean gaps;
11399         qboolean dynamicvertex;
11400         float amplitude;
11401         float animpos;
11402         float scale;
11403         float center[3], forward[3], right[3], up[3], v[3], newforward[3], newright[3], newup[3];
11404         float waveparms[4];
11405         q3shaderinfo_deform_t *deform;
11406         const msurface_t *surface, *firstsurface;
11407         r_vertexposition_t *vertexposition;
11408         r_vertexmesh_t *vertexmesh;
11409         if (!texturenumsurfaces)
11410                 return;
11411         // find vertex range of this surface batch
11412         gaps = false;
11413         firstsurface = texturesurfacelist[0];
11414         firsttriangle = firstsurface->num_firsttriangle;
11415         numtriangles = 0;
11416         firstvertex = endvertex = firstsurface->num_firstvertex;
11417         for (i = 0;i < texturenumsurfaces;i++)
11418         {
11419                 surface = texturesurfacelist[i];
11420                 if (surface != firstsurface + i)
11421                         gaps = true;
11422                 surfacefirstvertex = surface->num_firstvertex;
11423                 surfaceendvertex = surfacefirstvertex + surface->num_vertices;
11424                 surfacenumtriangles = surface->num_triangles;
11425                 if (firstvertex > surfacefirstvertex)
11426                         firstvertex = surfacefirstvertex;
11427                 if (endvertex < surfaceendvertex)
11428                         endvertex = surfaceendvertex;
11429                 numtriangles += surfacenumtriangles;
11430         }
11431
11432         // we now know the vertex range used, and if there are any gaps in it
11433         rsurface.batchfirstvertex = firstvertex;
11434         rsurface.batchnumvertices = endvertex - firstvertex;
11435         rsurface.batchfirsttriangle = firsttriangle;
11436         rsurface.batchnumtriangles = numtriangles;
11437
11438         // this variable holds flags for which properties have been updated that
11439         // may require regenerating vertexmesh or vertexposition arrays...
11440         needsupdate = 0;
11441
11442         // check if any dynamic vertex processing must occur
11443         dynamicvertex = false;
11444
11445         if ((batchneed & (BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_ARRAY_VERTEXCOLOR)) && texturesurfacelist[0]->lightmapinfo)
11446                 needsupdate |= BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_NOGAPS;
11447         for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform;deformindex++, deform++)
11448         {
11449                 switch (deform->deform)
11450                 {
11451                 default:
11452                 case Q3DEFORM_PROJECTIONSHADOW:
11453                 case Q3DEFORM_TEXT0:
11454                 case Q3DEFORM_TEXT1:
11455                 case Q3DEFORM_TEXT2:
11456                 case Q3DEFORM_TEXT3:
11457                 case Q3DEFORM_TEXT4:
11458                 case Q3DEFORM_TEXT5:
11459                 case Q3DEFORM_TEXT6:
11460                 case Q3DEFORM_TEXT7:
11461                 case Q3DEFORM_NONE:
11462                         break;
11463                 case Q3DEFORM_AUTOSPRITE:
11464                         dynamicvertex = true;
11465                         batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS;
11466                         needsupdate |= BATCHNEED_VERTEXPOSITION | BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
11467                         break;
11468                 case Q3DEFORM_AUTOSPRITE2:
11469                         dynamicvertex = true;
11470                         batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS;
11471                         needsupdate |= BATCHNEED_VERTEXPOSITION | BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
11472                         break;
11473                 case Q3DEFORM_NORMAL:
11474                         dynamicvertex = true;
11475                         batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS;
11476                         needsupdate |= BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
11477                         break;
11478                 case Q3DEFORM_WAVE:
11479                         if(!R_TestQ3WaveFunc(deform->wavefunc, deform->waveparms))
11480                                 break; // if wavefunc is a nop, ignore this transform
11481                         dynamicvertex = true;
11482                         batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS;
11483                         needsupdate |= BATCHNEED_VERTEXPOSITION | BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
11484                         break;
11485                 case Q3DEFORM_BULGE:
11486                         dynamicvertex = true;
11487                         batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS;
11488                         needsupdate |= BATCHNEED_VERTEXPOSITION | BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
11489                         break;
11490                 case Q3DEFORM_MOVE:
11491                         if(!R_TestQ3WaveFunc(deform->wavefunc, deform->waveparms))
11492                                 break; // if wavefunc is a nop, ignore this transform
11493                         dynamicvertex = true;
11494                         batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS;
11495                         needsupdate |= BATCHNEED_VERTEXPOSITION | BATCHNEED_VERTEXMESH_VERTEX;
11496                         break;
11497                 }
11498         }
11499         switch(rsurface.texture->tcgen.tcgen)
11500         {
11501         default:
11502         case Q3TCGEN_TEXTURE:
11503                 break;
11504         case Q3TCGEN_LIGHTMAP:
11505                 dynamicvertex = true;
11506                 batchneed |= BATCHNEED_ARRAY_LIGHTMAP | BATCHNEED_NOGAPS;
11507                 needsupdate |= BATCHNEED_VERTEXMESH_LIGHTMAP;
11508                 break;
11509         case Q3TCGEN_VECTOR:
11510                 dynamicvertex = true;
11511                 batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS;
11512                 needsupdate |= BATCHNEED_VERTEXMESH_TEXCOORD;
11513                 break;
11514         case Q3TCGEN_ENVIRONMENT:
11515                 dynamicvertex = true;
11516                 batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_NOGAPS;
11517                 needsupdate |= BATCHNEED_VERTEXMESH_TEXCOORD;
11518                 break;
11519         }
11520         if (rsurface.texture->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
11521         {
11522                 dynamicvertex = true;
11523                 batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS;
11524                 needsupdate |= BATCHNEED_VERTEXMESH_TEXCOORD;
11525         }
11526
11527         if (!rsurface.modelvertexmesh && (batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP)))
11528         {
11529                 dynamicvertex = true;
11530                 batchneed |= BATCHNEED_NOGAPS;
11531                 needsupdate |= (batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP));
11532         }
11533
11534         if (needsupdate & batchneed & BATCHNEED_VERTEXPOSITION)
11535         {
11536                 dynamicvertex = true;
11537                 batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS;
11538                 needsupdate |= (batchneed & BATCHNEED_VERTEXPOSITION);
11539         }
11540
11541         if (dynamicvertex || gaps || rsurface.batchfirstvertex)
11542         {
11543                 // when copying, we need to consider the regeneration of vertexmesh, any dependencies it may have must be set...
11544                 if (batchneed & BATCHNEED_VERTEXMESH_VERTEX)      batchneed |= BATCHNEED_ARRAY_VERTEX;
11545                 if (batchneed & BATCHNEED_VERTEXMESH_NORMAL)      batchneed |= BATCHNEED_ARRAY_NORMAL;
11546                 if (batchneed & BATCHNEED_VERTEXMESH_VECTOR)      batchneed |= BATCHNEED_ARRAY_VECTOR;
11547                 if (batchneed & BATCHNEED_VERTEXMESH_VERTEXCOLOR) batchneed |= BATCHNEED_ARRAY_VERTEXCOLOR;
11548                 if (batchneed & BATCHNEED_VERTEXMESH_TEXCOORD)    batchneed |= BATCHNEED_ARRAY_TEXCOORD;
11549                 if (batchneed & BATCHNEED_VERTEXMESH_LIGHTMAP)    batchneed |= BATCHNEED_ARRAY_LIGHTMAP;
11550         }
11551
11552         // when the model data has no vertex buffer (dynamic mesh), we need to
11553         // eliminate gaps
11554         if (!rsurface.modelvertexmeshbuffer)
11555                 batchneed |= BATCHNEED_NOGAPS;
11556
11557         // if needsupdate, we have to do a dynamic vertex batch for sure
11558         if (needsupdate & batchneed)
11559                 dynamicvertex = true;
11560
11561         // see if we need to build vertexmesh from arrays
11562         if (!rsurface.modelvertexmesh && (batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP)))
11563                 dynamicvertex = true;
11564
11565         // see if we need to build vertexposition from arrays
11566         if (!rsurface.modelvertexposition && (batchneed & BATCHNEED_VERTEXPOSITION))
11567                 dynamicvertex = true;
11568
11569         // if gaps are unacceptable, and there are gaps, it's a dynamic batch...
11570         if ((batchneed & BATCHNEED_NOGAPS) && (gaps || firstvertex))
11571                 dynamicvertex = true;
11572
11573         // if there is a chance of animated vertex colors, it's a dynamic batch
11574         if ((batchneed & (BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_ARRAY_VERTEXCOLOR)) && texturesurfacelist[0]->lightmapinfo)
11575                 dynamicvertex = true;
11576
11577         rsurface.batchvertex3f = rsurface.modelvertex3f;
11578         rsurface.batchvertex3f_vertexbuffer = rsurface.modelvertex3f_vertexbuffer;
11579         rsurface.batchvertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
11580         rsurface.batchsvector3f = rsurface.modelsvector3f;
11581         rsurface.batchsvector3f_vertexbuffer = rsurface.modelsvector3f_vertexbuffer;
11582         rsurface.batchsvector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
11583         rsurface.batchtvector3f = rsurface.modeltvector3f;
11584         rsurface.batchtvector3f_vertexbuffer = rsurface.modeltvector3f_vertexbuffer;
11585         rsurface.batchtvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
11586         rsurface.batchnormal3f = rsurface.modelnormal3f;
11587         rsurface.batchnormal3f_vertexbuffer = rsurface.modelnormal3f_vertexbuffer;
11588         rsurface.batchnormal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
11589         rsurface.batchlightmapcolor4f = rsurface.modellightmapcolor4f;
11590         rsurface.batchlightmapcolor4f_vertexbuffer  = rsurface.modellightmapcolor4f_vertexbuffer;
11591         rsurface.batchlightmapcolor4f_bufferoffset  = rsurface.modellightmapcolor4f_bufferoffset;
11592         rsurface.batchtexcoordtexture2f = rsurface.modeltexcoordtexture2f;
11593         rsurface.batchtexcoordtexture2f_vertexbuffer  = rsurface.modeltexcoordtexture2f_vertexbuffer;
11594         rsurface.batchtexcoordtexture2f_bufferoffset  = rsurface.modeltexcoordtexture2f_bufferoffset;
11595         rsurface.batchtexcoordlightmap2f = rsurface.modeltexcoordlightmap2f;
11596         rsurface.batchtexcoordlightmap2f_vertexbuffer = rsurface.modeltexcoordlightmap2f_vertexbuffer;
11597         rsurface.batchtexcoordlightmap2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
11598         rsurface.batchvertexposition = rsurface.modelvertexposition;
11599         rsurface.batchvertexpositionbuffer = rsurface.modelvertexpositionbuffer;
11600         rsurface.batchvertexmesh = rsurface.modelvertexmesh;
11601         rsurface.batchvertexmeshbuffer = rsurface.modelvertexmeshbuffer;
11602         rsurface.batchelement3i = rsurface.modelelement3i;
11603         rsurface.batchelement3i_indexbuffer = rsurface.modelelement3i_indexbuffer;
11604         rsurface.batchelement3i_bufferoffset = rsurface.modelelement3i_bufferoffset;
11605         rsurface.batchelement3s = rsurface.modelelement3s;
11606         rsurface.batchelement3s_indexbuffer = rsurface.modelelement3s_indexbuffer;
11607         rsurface.batchelement3s_bufferoffset = rsurface.modelelement3s_bufferoffset;
11608
11609         // if any dynamic vertex processing has to occur in software, we copy the
11610         // entire surface list together before processing to rebase the vertices
11611         // to start at 0 (otherwise we waste a lot of room in a vertex buffer).
11612         //
11613         // if any gaps exist and we do not have a static vertex buffer, we have to
11614         // copy the surface list together to avoid wasting upload bandwidth on the
11615         // vertices in the gaps.
11616         //
11617         // if gaps exist and we have a static vertex buffer, we still have to
11618         // combine the index buffer ranges into one dynamic index buffer.
11619         //
11620         // in all cases we end up with data that can be drawn in one call.
11621
11622         if (!dynamicvertex)
11623         {
11624                 // static vertex data, just set pointers...
11625                 rsurface.batchgeneratedvertex = false;
11626                 // if there are gaps, we want to build a combined index buffer,
11627                 // otherwise use the original static buffer with an appropriate offset
11628                 if (gaps)
11629                 {
11630                         firsttriangle = 0;
11631                         numtriangles = 0;
11632                         for (i = 0;i < texturenumsurfaces;i++)
11633                         {
11634                                 surfacefirsttriangle = texturesurfacelist[i]->num_firsttriangle;
11635                                 surfacenumtriangles = texturesurfacelist[i]->num_triangles;
11636                                 memcpy(rsurface.array_batchelement3i + 3*numtriangles, rsurface.modelelement3i + 3*surfacefirsttriangle, surfacenumtriangles*sizeof(int[3]));
11637                                 numtriangles += surfacenumtriangles;
11638                         }
11639                         rsurface.batchelement3i = rsurface.array_batchelement3i;
11640                         rsurface.batchelement3i_indexbuffer = NULL;
11641                         rsurface.batchelement3i_bufferoffset = 0;
11642                         rsurface.batchelement3s = NULL;
11643                         rsurface.batchelement3s_indexbuffer = NULL;
11644                         rsurface.batchelement3s_bufferoffset = 0;
11645                         if (endvertex <= 65536)
11646                         {
11647                                 rsurface.batchelement3s = rsurface.array_batchelement3s;
11648                                 for (i = 0;i < numtriangles*3;i++)
11649                                         rsurface.array_batchelement3s[i] = rsurface.array_batchelement3i[i];
11650                         }
11651                         rsurface.batchfirsttriangle = firsttriangle;
11652                         rsurface.batchnumtriangles = numtriangles;
11653                 }
11654                 return;
11655         }
11656
11657         // something needs software processing, do it for real...
11658         // we only directly handle interleaved array data in this case...
11659         rsurface.batchgeneratedvertex = true;
11660
11661         // now copy the vertex data into a combined array and make an index array
11662         // (this is what Quake3 does all the time)
11663         //if (gaps || rsurface.batchfirstvertex)
11664         {
11665                 rsurface.batchvertexposition = NULL;
11666                 rsurface.batchvertexpositionbuffer = NULL;
11667                 rsurface.batchvertexmesh = NULL;
11668                 rsurface.batchvertexmeshbuffer = NULL;
11669                 rsurface.batchvertex3f = NULL;
11670                 rsurface.batchvertex3f_vertexbuffer = NULL;
11671                 rsurface.batchvertex3f_bufferoffset = 0;
11672                 rsurface.batchsvector3f = NULL;
11673                 rsurface.batchsvector3f_vertexbuffer = NULL;
11674                 rsurface.batchsvector3f_bufferoffset = 0;
11675                 rsurface.batchtvector3f = NULL;
11676                 rsurface.batchtvector3f_vertexbuffer = NULL;
11677                 rsurface.batchtvector3f_bufferoffset = 0;
11678                 rsurface.batchnormal3f = NULL;
11679                 rsurface.batchnormal3f_vertexbuffer = NULL;
11680                 rsurface.batchnormal3f_bufferoffset = 0;
11681                 rsurface.batchlightmapcolor4f = NULL;
11682                 rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
11683                 rsurface.batchlightmapcolor4f_bufferoffset = 0;
11684                 rsurface.batchtexcoordtexture2f = NULL;
11685                 rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
11686                 rsurface.batchtexcoordtexture2f_bufferoffset = 0;
11687                 rsurface.batchtexcoordlightmap2f = NULL;
11688                 rsurface.batchtexcoordlightmap2f_vertexbuffer = NULL;
11689                 rsurface.batchtexcoordlightmap2f_bufferoffset = 0;
11690                 rsurface.batchelement3i = rsurface.array_batchelement3i;
11691                 rsurface.batchelement3i_indexbuffer = NULL;
11692                 rsurface.batchelement3i_bufferoffset = 0;
11693                 rsurface.batchelement3s = NULL;
11694                 rsurface.batchelement3s_indexbuffer = NULL;
11695                 rsurface.batchelement3s_bufferoffset = 0;
11696                 // we'll only be setting up certain arrays as needed
11697                 if (batchneed & BATCHNEED_VERTEXPOSITION)
11698                         rsurface.batchvertexposition = rsurface.array_batchvertexposition;
11699                 if (batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP))
11700                         rsurface.batchvertexmesh = rsurface.array_batchvertexmesh;
11701                 if (batchneed & BATCHNEED_ARRAY_VERTEX)
11702                         rsurface.batchvertex3f = rsurface.array_batchvertex3f;
11703                 if (batchneed & BATCHNEED_ARRAY_NORMAL)
11704                         rsurface.batchnormal3f = rsurface.array_batchnormal3f;
11705                 if (batchneed & BATCHNEED_ARRAY_VECTOR)
11706                 {
11707                         rsurface.batchsvector3f = rsurface.array_batchsvector3f;
11708                         rsurface.batchtvector3f = rsurface.array_batchtvector3f;
11709                 }
11710                 if (batchneed & BATCHNEED_ARRAY_VERTEXCOLOR)
11711                         rsurface.batchlightmapcolor4f = rsurface.array_batchlightmapcolor4f;
11712                 if (batchneed & BATCHNEED_ARRAY_TEXCOORD)
11713                         rsurface.batchtexcoordtexture2f = rsurface.array_batchtexcoordtexture2f;
11714                 if (batchneed & BATCHNEED_ARRAY_LIGHTMAP)
11715                         rsurface.batchtexcoordlightmap2f = rsurface.array_batchtexcoordlightmap2f;
11716                 numvertices = 0;
11717                 numtriangles = 0;
11718                 for (i = 0;i < texturenumsurfaces;i++)
11719                 {
11720                         surfacefirstvertex = texturesurfacelist[i]->num_firstvertex;
11721                         surfacenumvertices = texturesurfacelist[i]->num_vertices;
11722                         surfacefirsttriangle = texturesurfacelist[i]->num_firsttriangle;
11723                         surfacenumtriangles = texturesurfacelist[i]->num_triangles;
11724                         // copy only the data requested
11725                         if ((batchneed & BATCHNEED_VERTEXPOSITION) && rsurface.modelvertexposition)
11726                                 memcpy(rsurface.array_batchvertexposition + numvertices, rsurface.modelvertexposition + surfacefirstvertex, surfacenumvertices * sizeof(rsurface.batchvertexposition[0]));
11727                         if ((batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP)) && rsurface.modelvertexmesh)
11728                                 memcpy(rsurface.array_batchvertexmesh + numvertices, rsurface.modelvertexmesh + surfacefirstvertex, surfacenumvertices * sizeof(rsurface.batchvertexmesh[0]));
11729                         if (batchneed & (BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | BATCHNEED_ARRAY_VERTEXCOLOR | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_ARRAY_LIGHTMAP))
11730                         {
11731                                 if (batchneed & BATCHNEED_ARRAY_VERTEX)
11732                                         memcpy(rsurface.array_batchvertex3f + 3*numvertices, rsurface.modelvertex3f + 3*surfacefirstvertex, surfacenumvertices * sizeof(float[3]));
11733                                 if ((batchneed & BATCHNEED_ARRAY_NORMAL) && rsurface.modelnormal3f)
11734                                         memcpy(rsurface.array_batchnormal3f + 3*numvertices, rsurface.modelnormal3f + 3*surfacefirstvertex, surfacenumvertices * sizeof(float[3]));
11735                                 if ((batchneed & BATCHNEED_ARRAY_VECTOR) && rsurface.modelsvector3f)
11736                                 {
11737                                         memcpy(rsurface.array_batchsvector3f + 3*numvertices, rsurface.modelsvector3f + 3*surfacefirstvertex, surfacenumvertices * sizeof(float[3]));
11738                                         memcpy(rsurface.array_batchtvector3f + 3*numvertices, rsurface.modeltvector3f + 3*surfacefirstvertex, surfacenumvertices * sizeof(float[3]));
11739                                 }
11740                                 if ((batchneed & BATCHNEED_ARRAY_VERTEXCOLOR) && rsurface.modellightmapcolor4f)
11741                                         memcpy(rsurface.array_batchlightmapcolor4f + 4*numvertices, rsurface.modellightmapcolor4f + 4*surfacefirstvertex, surfacenumvertices * sizeof(float[4]));
11742                                 if ((batchneed & BATCHNEED_ARRAY_TEXCOORD) && rsurface.modeltexcoordtexture2f)
11743                                         memcpy(rsurface.array_batchtexcoordtexture2f + 2*numvertices, rsurface.modeltexcoordtexture2f + 2*surfacefirstvertex, surfacenumvertices * sizeof(float[2]));
11744                                 if ((batchneed & BATCHNEED_ARRAY_LIGHTMAP) && rsurface.modeltexcoordlightmap2f)
11745                                         memcpy(rsurface.array_batchtexcoordlightmap2f + 2*numvertices, rsurface.modeltexcoordlightmap2f + 2*surfacefirstvertex, surfacenumvertices * sizeof(float[2]));
11746                         }
11747                         RSurf_RenumberElements(rsurface.modelelement3i + 3*surfacefirsttriangle, rsurface.array_batchelement3i + 3*numtriangles, 3*surfacenumtriangles, numvertices - surfacefirstvertex);
11748                         numvertices += surfacenumvertices;
11749                         numtriangles += surfacenumtriangles;
11750                 }
11751
11752                 // generate a 16bit index array as well if possible
11753                 // (in general, dynamic batches fit)
11754                 if (numvertices <= 65536)
11755                 {
11756                         rsurface.batchelement3s = rsurface.array_batchelement3s;
11757                         for (i = 0;i < numtriangles*3;i++)
11758                                 rsurface.array_batchelement3s[i] = rsurface.array_batchelement3i[i];
11759                 }
11760
11761                 // since we've copied everything, the batch now starts at 0
11762                 rsurface.batchfirstvertex = 0;
11763                 rsurface.batchnumvertices = numvertices;
11764                 rsurface.batchfirsttriangle = 0;
11765                 rsurface.batchnumtriangles = numtriangles;
11766         }
11767
11768         // q1bsp surfaces rendered in vertex color mode have to have colors
11769         // calculated based on lightstyles
11770         if ((batchneed & (BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_ARRAY_VERTEXCOLOR)) && texturesurfacelist[0]->lightmapinfo)
11771         {
11772                 // generate color arrays for the surfaces in this list
11773                 int c[4];
11774                 int scale;
11775                 int size3;
11776                 const int *offsets;
11777                 const unsigned char *lm;
11778                 numvertices = 0;
11779                 rsurface.batchlightmapcolor4f = rsurface.array_batchlightmapcolor4f;
11780                 rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
11781                 rsurface.batchlightmapcolor4f_bufferoffset = 0;
11782                 for (i = 0;i < texturenumsurfaces;i++)
11783                 {
11784                         surface = texturesurfacelist[i];
11785                         offsets = rsurface.modellightmapoffsets + surface->num_firstvertex;
11786                         surfacenumvertices = surface->num_vertices;
11787                         if (surface->lightmapinfo->samples)
11788                         {
11789                                 for (j = 0;j < surfacenumvertices;j++)
11790                                 {
11791                                         lm = surface->lightmapinfo->samples + offsets[j];
11792                                         scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[0]];
11793                                         VectorScale(lm, scale, c);
11794                                         if (surface->lightmapinfo->styles[1] != 255)
11795                                         {
11796                                                 size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
11797                                                 lm += size3;
11798                                                 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[1]];
11799                                                 VectorMA(c, scale, lm, c);
11800                                                 if (surface->lightmapinfo->styles[2] != 255)
11801                                                 {
11802                                                         lm += size3;
11803                                                         scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[2]];
11804                                                         VectorMA(c, scale, lm, c);
11805                                                         if (surface->lightmapinfo->styles[3] != 255)
11806                                                         {
11807                                                                 lm += size3;
11808                                                                 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[3]];
11809                                                                 VectorMA(c, scale, lm, c);
11810                                                         }
11811                                                 }
11812                                         }
11813                                         c[0] >>= 15;
11814                                         c[1] >>= 15;
11815                                         c[2] >>= 15;
11816                                         Vector4Set(rsurface.array_batchlightmapcolor4f + 4*numvertices, min(c[0], 255) * (1.0f / 255.0f), min(c[1], 255) * (1.0f / 255.0f), min(c[2], 255) * (1.0f / 255.0f), 1);
11817                                         numvertices++;
11818                                 }
11819                         }
11820                         else
11821                         {
11822                                 for (j = 0;j < surfacenumvertices;j++)
11823                                 {
11824                                         Vector4Set(rsurface.array_batchlightmapcolor4f + 4*numvertices, 0, 0, 0, 1);
11825                                         numvertices++;
11826                                 }
11827                         }
11828                 }
11829         }
11830
11831         // if vertices are deformed (sprite flares and things in maps, possibly
11832         // water waves, bulges and other deformations), modify the copied vertices
11833         // in place
11834         for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform;deformindex++, deform++)
11835         {
11836                 switch (deform->deform)
11837                 {
11838                 default:
11839                 case Q3DEFORM_PROJECTIONSHADOW:
11840                 case Q3DEFORM_TEXT0:
11841                 case Q3DEFORM_TEXT1:
11842                 case Q3DEFORM_TEXT2:
11843                 case Q3DEFORM_TEXT3:
11844                 case Q3DEFORM_TEXT4:
11845                 case Q3DEFORM_TEXT5:
11846                 case Q3DEFORM_TEXT6:
11847                 case Q3DEFORM_TEXT7:
11848                 case Q3DEFORM_NONE:
11849                         break;
11850                 case Q3DEFORM_AUTOSPRITE:
11851                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
11852                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
11853                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
11854                         VectorNormalize(newforward);
11855                         VectorNormalize(newright);
11856                         VectorNormalize(newup);
11857                         // a single autosprite surface can contain multiple sprites...
11858                         for (j = 0;j < rsurface.batchnumvertices - 3;j += 4)
11859                         {
11860                                 VectorClear(center);
11861                                 for (i = 0;i < 4;i++)
11862                                         VectorAdd(center, rsurface.batchvertex3f + 3*(j+i), center);
11863                                 VectorScale(center, 0.25f, center);
11864                                 VectorCopy(rsurface.batchnormal3f + 3*j, forward);
11865                                 VectorCopy(rsurface.batchsvector3f + 3*j, right);
11866                                 VectorCopy(rsurface.batchtvector3f + 3*j, up);
11867                                 for (i = 0;i < 4;i++)
11868                                 {
11869                                         VectorSubtract(rsurface.batchvertex3f + 3*(j+i), center, v);
11870                                         VectorMAMAMAM(1, center, DotProduct(forward, v), newforward, DotProduct(right, v), newright, DotProduct(up, v), newup, rsurface.array_batchvertex3f + 3*(j+i));
11871                                 }
11872                         }
11873                         // if we get here, BATCHNEED_ARRAY_NORMAL and BATCHNEED_ARRAY_VECTOR are in batchneed, so no need to check
11874                         Mod_BuildNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchnormal3f, r_smoothnormals_areaweighting.integer != 0);
11875                         Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.array_batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchsvector3f, rsurface.array_batchtvector3f, r_smoothnormals_areaweighting.integer != 0);
11876                         rsurface.batchvertex3f = rsurface.array_batchvertex3f;
11877                         rsurface.batchvertex3f_vertexbuffer = NULL;
11878                         rsurface.batchvertex3f_bufferoffset = 0;
11879                         rsurface.batchsvector3f = rsurface.array_batchsvector3f;
11880                         rsurface.batchsvector3f_vertexbuffer = NULL;
11881                         rsurface.batchsvector3f_bufferoffset = 0;
11882                         rsurface.batchtvector3f = rsurface.array_batchtvector3f;
11883                         rsurface.batchtvector3f_vertexbuffer = NULL;
11884                         rsurface.batchtvector3f_bufferoffset = 0;
11885                         rsurface.batchnormal3f = rsurface.array_batchnormal3f;
11886                         rsurface.batchnormal3f_vertexbuffer = NULL;
11887                         rsurface.batchnormal3f_bufferoffset = 0;
11888                         break;
11889                 case Q3DEFORM_AUTOSPRITE2:
11890                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
11891                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
11892                         Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
11893                         VectorNormalize(newforward);
11894                         VectorNormalize(newright);
11895                         VectorNormalize(newup);
11896                         {
11897                                 const float *v1, *v2;
11898                                 vec3_t start, end;
11899                                 float f, l;
11900                                 struct
11901                                 {
11902                                         float length2;
11903                                         const float *v1;
11904                                         const float *v2;
11905                                 }
11906                                 shortest[2];
11907                                 memset(shortest, 0, sizeof(shortest));
11908                                 // a single autosprite surface can contain multiple sprites...
11909                                 for (j = 0;j < rsurface.batchnumvertices - 3;j += 4)
11910                                 {
11911                                         VectorClear(center);
11912                                         for (i = 0;i < 4;i++)
11913                                                 VectorAdd(center, rsurface.batchvertex3f + 3*(j+i), center);
11914                                         VectorScale(center, 0.25f, center);
11915                                         // find the two shortest edges, then use them to define the
11916                                         // axis vectors for rotating around the central axis
11917                                         for (i = 0;i < 6;i++)
11918                                         {
11919                                                 v1 = rsurface.batchvertex3f + 3*(j+quadedges[i][0]);
11920                                                 v2 = rsurface.batchvertex3f + 3*(j+quadedges[i][1]);
11921                                                 l = VectorDistance2(v1, v2);
11922                                                 // this length bias tries to make sense of square polygons, assuming they are meant to be upright
11923                                                 if (v1[2] != v2[2])
11924                                                         l += (1.0f / 1024.0f);
11925                                                 if (shortest[0].length2 > l || i == 0)
11926                                                 {
11927                                                         shortest[1] = shortest[0];
11928                                                         shortest[0].length2 = l;
11929                                                         shortest[0].v1 = v1;
11930                                                         shortest[0].v2 = v2;
11931                                                 }
11932                                                 else if (shortest[1].length2 > l || i == 1)
11933                                                 {
11934                                                         shortest[1].length2 = l;
11935                                                         shortest[1].v1 = v1;
11936                                                         shortest[1].v2 = v2;
11937                                                 }
11938                                         }
11939                                         VectorLerp(shortest[0].v1, 0.5f, shortest[0].v2, start);
11940                                         VectorLerp(shortest[1].v1, 0.5f, shortest[1].v2, end);
11941                                         // this calculates the right vector from the shortest edge
11942                                         // and the up vector from the edge midpoints
11943                                         VectorSubtract(shortest[0].v1, shortest[0].v2, right);
11944                                         VectorNormalize(right);
11945                                         VectorSubtract(end, start, up);
11946                                         VectorNormalize(up);
11947                                         // calculate a forward vector to use instead of the original plane normal (this is how we get a new right vector)
11948                                         VectorSubtract(rsurface.localvieworigin, center, forward);
11949                                         //Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, forward);
11950                                         VectorNegate(forward, forward);
11951                                         VectorReflect(forward, 0, up, forward);
11952                                         VectorNormalize(forward);
11953                                         CrossProduct(up, forward, newright);
11954                                         VectorNormalize(newright);
11955                                         // rotate the quad around the up axis vector, this is made
11956                                         // especially easy by the fact we know the quad is flat,
11957                                         // so we only have to subtract the center position and
11958                                         // measure distance along the right vector, and then
11959                                         // multiply that by the newright vector and add back the
11960                                         // center position
11961                                         // we also need to subtract the old position to undo the
11962                                         // displacement from the center, which we do with a
11963                                         // DotProduct, the subtraction/addition of center is also
11964                                         // optimized into DotProducts here
11965                                         l = DotProduct(right, center);
11966                                         for (i = 0;i < 4;i++)
11967                                         {
11968                                                 v1 = rsurface.batchvertex3f + 3*(j+i);
11969                                                 f = DotProduct(right, v1) - l;
11970                                                 VectorMAMAM(1, v1, -f, right, f, newright, rsurface.array_batchvertex3f + 3*(j+i));
11971                                         }
11972                                 }
11973                         }
11974                         rsurface.batchvertex3f = rsurface.array_batchvertex3f;
11975                         rsurface.batchvertex3f_vertexbuffer = NULL;
11976                         rsurface.batchvertex3f_bufferoffset = 0;
11977                         if(batchneed & (BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR)) // otherwise these can stay NULL
11978                         {
11979                                 Mod_BuildNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchnormal3f, r_smoothnormals_areaweighting.integer != 0);
11980                                 rsurface.batchnormal3f = rsurface.array_batchnormal3f;
11981                                 rsurface.batchnormal3f_vertexbuffer = NULL;
11982                                 rsurface.batchnormal3f_bufferoffset = 0;
11983                         }
11984                         if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL
11985                         {
11986                                 Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.array_batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchsvector3f, rsurface.array_batchtvector3f, r_smoothnormals_areaweighting.integer != 0);
11987                                 rsurface.batchsvector3f = rsurface.array_batchsvector3f;
11988                                 rsurface.batchsvector3f_vertexbuffer = NULL;
11989                                 rsurface.batchsvector3f_bufferoffset = 0;
11990                                 rsurface.batchtvector3f = rsurface.array_batchtvector3f;
11991                                 rsurface.batchtvector3f_vertexbuffer = NULL;
11992                                 rsurface.batchtvector3f_bufferoffset = 0;
11993                         }
11994                         break;
11995                 case Q3DEFORM_NORMAL:
11996                         // deform the normals to make reflections wavey
11997                         for (j = 0;j < rsurface.batchnumvertices;j++)
11998                         {
11999                                 float vertex[3];
12000                                 float *normal = rsurface.array_batchnormal3f + 3*j;
12001                                 VectorScale(rsurface.batchvertex3f + 3*j, 0.98f, vertex);
12002                                 normal[0] = rsurface.batchnormal3f[j*3+0] + deform->parms[0] * noise4f(      vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
12003                                 normal[1] = rsurface.batchnormal3f[j*3+1] + deform->parms[0] * noise4f( 98 + vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
12004                                 normal[2] = rsurface.batchnormal3f[j*3+2] + deform->parms[0] * noise4f(196 + vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
12005                                 VectorNormalize(normal);
12006                         }
12007                         rsurface.batchnormal3f = rsurface.array_batchnormal3f;
12008                         rsurface.batchnormal3f_vertexbuffer = NULL;
12009                         rsurface.batchnormal3f_bufferoffset = 0;
12010                         if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL
12011                         {
12012                                 Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.array_batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchsvector3f, rsurface.array_batchtvector3f, r_smoothnormals_areaweighting.integer != 0);
12013                                 rsurface.batchsvector3f = rsurface.array_batchsvector3f;
12014                                 rsurface.batchsvector3f_vertexbuffer = NULL;
12015                                 rsurface.batchsvector3f_bufferoffset = 0;
12016                                 rsurface.batchtvector3f = rsurface.array_batchtvector3f;
12017                                 rsurface.batchtvector3f_vertexbuffer = NULL;
12018                                 rsurface.batchtvector3f_bufferoffset = 0;
12019                         }
12020                         break;
12021                 case Q3DEFORM_WAVE:
12022                         // deform vertex array to make wavey water and flags and such
12023                         waveparms[0] = deform->waveparms[0];
12024                         waveparms[1] = deform->waveparms[1];
12025                         waveparms[2] = deform->waveparms[2];
12026                         waveparms[3] = deform->waveparms[3];
12027                         if(!R_TestQ3WaveFunc(deform->wavefunc, waveparms))
12028                                 break; // if wavefunc is a nop, don't make a dynamic vertex array
12029                         // this is how a divisor of vertex influence on deformation
12030                         animpos = deform->parms[0] ? 1.0f / deform->parms[0] : 100.0f;
12031                         scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
12032                         for (j = 0;j < rsurface.batchnumvertices;j++)
12033                         {
12034                                 // if the wavefunc depends on time, evaluate it per-vertex
12035                                 if (waveparms[3])
12036                                 {
12037                                         waveparms[2] = deform->waveparms[2] + (rsurface.batchvertex3f[j*3+0] + rsurface.batchvertex3f[j*3+1] + rsurface.batchvertex3f[j*3+2]) * animpos;
12038                                         scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
12039                                 }
12040                                 VectorMA(rsurface.batchvertex3f + 3*j, scale, rsurface.batchnormal3f + 3*j, rsurface.array_batchvertex3f + 3*j);
12041                         }
12042                         // if we get here, BATCHNEED_ARRAY_NORMAL is in batchneed, so no need to check
12043                         Mod_BuildNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchnormal3f, r_smoothnormals_areaweighting.integer != 0);
12044                         rsurface.batchvertex3f = rsurface.array_batchvertex3f;
12045                         rsurface.batchvertex3f_vertexbuffer = NULL;
12046                         rsurface.batchvertex3f_bufferoffset = 0;
12047                         rsurface.batchnormal3f = rsurface.array_batchnormal3f;
12048                         rsurface.batchnormal3f_vertexbuffer = NULL;
12049                         rsurface.batchnormal3f_bufferoffset = 0;
12050                         if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL
12051                         {
12052                                 Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.array_batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchsvector3f, rsurface.array_batchtvector3f, r_smoothnormals_areaweighting.integer != 0);
12053                                 rsurface.batchsvector3f = rsurface.array_batchsvector3f;
12054                                 rsurface.batchsvector3f_vertexbuffer = NULL;
12055                                 rsurface.batchsvector3f_bufferoffset = 0;
12056                                 rsurface.batchtvector3f = rsurface.array_batchtvector3f;
12057                                 rsurface.batchtvector3f_vertexbuffer = NULL;
12058                                 rsurface.batchtvector3f_bufferoffset = 0;
12059                         }
12060                         break;
12061                 case Q3DEFORM_BULGE:
12062                         // deform vertex array to make the surface have moving bulges
12063                         for (j = 0;j < rsurface.batchnumvertices;j++)
12064                         {
12065                                 scale = sin(rsurface.batchtexcoordtexture2f[j*2+0] * deform->parms[0] + r_refdef.scene.time * deform->parms[2]) * deform->parms[1];
12066                                 VectorMA(rsurface.batchvertex3f + 3*j, scale, rsurface.batchnormal3f + 3*j, rsurface.array_batchvertex3f + 3*j);
12067                         }
12068                         // if we get here, BATCHNEED_ARRAY_NORMAL is in batchneed, so no need to check
12069                         Mod_BuildNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchnormal3f, r_smoothnormals_areaweighting.integer != 0);
12070                         rsurface.batchvertex3f = rsurface.array_batchvertex3f;
12071                         rsurface.batchvertex3f_vertexbuffer = NULL;
12072                         rsurface.batchvertex3f_bufferoffset = 0;
12073                         rsurface.batchnormal3f = rsurface.array_batchnormal3f;
12074                         rsurface.batchnormal3f_vertexbuffer = NULL;
12075                         rsurface.batchnormal3f_bufferoffset = 0;
12076                         if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL
12077                         {
12078                                 Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.array_batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchsvector3f, rsurface.array_batchtvector3f, r_smoothnormals_areaweighting.integer != 0);
12079                                 rsurface.batchsvector3f = rsurface.array_batchsvector3f;
12080                                 rsurface.batchsvector3f_vertexbuffer = NULL;
12081                                 rsurface.batchsvector3f_bufferoffset = 0;
12082                                 rsurface.batchtvector3f = rsurface.array_batchtvector3f;
12083                                 rsurface.batchtvector3f_vertexbuffer = NULL;
12084                                 rsurface.batchtvector3f_bufferoffset = 0;
12085                         }
12086                         break;
12087                 case Q3DEFORM_MOVE:
12088                         // deform vertex array
12089                         if(!R_TestQ3WaveFunc(deform->wavefunc, deform->waveparms))
12090                                 break; // if wavefunc is a nop, don't make a dynamic vertex array
12091                         scale = R_EvaluateQ3WaveFunc(deform->wavefunc, deform->waveparms);
12092                         VectorScale(deform->parms, scale, waveparms);
12093                         for (j = 0;j < rsurface.batchnumvertices;j++)
12094                                 VectorAdd(rsurface.batchvertex3f + 3*j, waveparms, rsurface.array_batchvertex3f + 3*j);
12095                         rsurface.batchvertex3f = rsurface.array_batchvertex3f;
12096                         rsurface.batchvertex3f_vertexbuffer = NULL;
12097                         rsurface.batchvertex3f_bufferoffset = 0;
12098                         break;
12099                 }
12100         }
12101
12102         // generate texcoords based on the chosen texcoord source
12103         switch(rsurface.texture->tcgen.tcgen)
12104         {
12105         default:
12106         case Q3TCGEN_TEXTURE:
12107                 break;
12108         case Q3TCGEN_LIGHTMAP:
12109                 if (rsurface.batchtexcoordlightmap2f)
12110                         memcpy(rsurface.array_batchtexcoordlightmap2f, rsurface.batchtexcoordtexture2f, rsurface.batchnumvertices * sizeof(float[2]));
12111                 rsurface.batchtexcoordtexture2f = rsurface.array_batchtexcoordtexture2f;
12112                 rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
12113                 rsurface.batchtexcoordtexture2f_bufferoffset = 0;
12114                 break;
12115         case Q3TCGEN_VECTOR:
12116                 for (j = 0;j < rsurface.batchnumvertices;j++)
12117                 {
12118                         rsurface.array_batchtexcoordtexture2f[j*2+0] = DotProduct(rsurface.batchvertex3f + 3*j, rsurface.texture->tcgen.parms);
12119                         rsurface.array_batchtexcoordtexture2f[j*2+1] = DotProduct(rsurface.batchvertex3f + 3*j, rsurface.texture->tcgen.parms + 3);
12120                 }
12121                 rsurface.batchtexcoordtexture2f = rsurface.array_batchtexcoordtexture2f;
12122                 rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
12123                 rsurface.batchtexcoordtexture2f_bufferoffset = 0;
12124                 break;
12125         case Q3TCGEN_ENVIRONMENT:
12126                 // make environment reflections using a spheremap
12127                 for (j = 0;j < rsurface.batchnumvertices;j++)
12128                 {
12129                         // identical to Q3A's method, but executed in worldspace so
12130                         // carried models can be shiny too
12131
12132                         float viewer[3], d, reflected[3], worldreflected[3];
12133
12134                         VectorSubtract(rsurface.localvieworigin, rsurface.batchvertex3f + 3*j, viewer);
12135                         // VectorNormalize(viewer);
12136
12137                         d = DotProduct(rsurface.batchnormal3f + 3*j, viewer);
12138
12139                         reflected[0] = rsurface.batchnormal3f[j*3+0]*2*d - viewer[0];
12140                         reflected[1] = rsurface.batchnormal3f[j*3+1]*2*d - viewer[1];
12141                         reflected[2] = rsurface.batchnormal3f[j*3+2]*2*d - viewer[2];
12142                         // note: this is proportinal to viewer, so we can normalize later
12143
12144                         Matrix4x4_Transform3x3(&rsurface.matrix, reflected, worldreflected);
12145                         VectorNormalize(worldreflected);
12146
12147                         // note: this sphere map only uses world x and z!
12148                         // so positive and negative y will LOOK THE SAME.
12149                         rsurface.array_batchtexcoordtexture2f[j*2+0] = 0.5 + 0.5 * worldreflected[1];
12150                         rsurface.array_batchtexcoordtexture2f[j*2+1] = 0.5 - 0.5 * worldreflected[2];
12151                 }
12152                 rsurface.batchtexcoordtexture2f = rsurface.array_batchtexcoordtexture2f;
12153                 rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
12154                 rsurface.batchtexcoordtexture2f_bufferoffset = 0;
12155                 break;
12156         }
12157         // the only tcmod that needs software vertex processing is turbulent, so
12158         // check for it here and apply the changes if needed
12159         // and we only support that as the first one
12160         // (handling a mixture of turbulent and other tcmods would be problematic
12161         //  without punting it entirely to a software path)
12162         if (rsurface.texture->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
12163         {
12164                 amplitude = rsurface.texture->tcmods[0].parms[1];
12165                 animpos = rsurface.texture->tcmods[0].parms[2] + r_refdef.scene.time * rsurface.texture->tcmods[0].parms[3];
12166                 for (j = 0;j < rsurface.batchnumvertices;j++)
12167                 {
12168                         rsurface.array_batchtexcoordtexture2f[j*2+0] += amplitude * sin(((rsurface.batchvertex3f[j*3+0] + rsurface.batchvertex3f[j*3+2]) * 1.0 / 1024.0f + animpos) * M_PI * 2);
12169                         rsurface.array_batchtexcoordtexture2f[j*2+1] += amplitude * sin(((rsurface.batchvertex3f[j*3+1]                                ) * 1.0 / 1024.0f + animpos) * M_PI * 2);
12170                 }
12171                 rsurface.batchtexcoordtexture2f = rsurface.array_batchtexcoordtexture2f;
12172                 rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
12173                 rsurface.batchtexcoordtexture2f_bufferoffset = 0;
12174         }
12175
12176         if (needsupdate & batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP))
12177         {
12178                 // convert the modified arrays to vertex structs
12179                 rsurface.batchvertexmesh = rsurface.array_batchvertexmesh;
12180                 rsurface.batchvertexmeshbuffer = NULL;
12181                 if (batchneed & BATCHNEED_VERTEXMESH_VERTEX)
12182                         for (j = 0, vertexmesh = rsurface.array_batchvertexmesh;j < rsurface.batchnumvertices;j++, vertexmesh++)
12183                                 VectorCopy(rsurface.batchvertex3f + 3*j, vertexmesh->vertex3f);
12184                 if (batchneed & BATCHNEED_VERTEXMESH_NORMAL)
12185                         for (j = 0, vertexmesh = rsurface.array_batchvertexmesh;j < rsurface.batchnumvertices;j++, vertexmesh++)
12186                                 VectorCopy(rsurface.batchnormal3f + 3*j, vertexmesh->normal3f);
12187                 if (batchneed & BATCHNEED_VERTEXMESH_VECTOR)
12188                 {
12189                         for (j = 0, vertexmesh = rsurface.array_batchvertexmesh;j < rsurface.batchnumvertices;j++, vertexmesh++)
12190                         {
12191                                 VectorCopy(rsurface.batchsvector3f + 3*j, vertexmesh->svector3f);
12192                                 VectorCopy(rsurface.batchtvector3f + 3*j, vertexmesh->tvector3f);
12193                         }
12194                 }
12195                 if ((batchneed & BATCHNEED_VERTEXMESH_VERTEXCOLOR) && rsurface.batchlightmapcolor4f)
12196                         for (j = 0, vertexmesh = rsurface.array_batchvertexmesh;j < rsurface.batchnumvertices;j++, vertexmesh++)
12197                                 Vector4Scale(rsurface.batchlightmapcolor4f + 4*j, 255.0f, vertexmesh->color4ub);
12198                 if (batchneed & BATCHNEED_VERTEXMESH_TEXCOORD)
12199                         for (j = 0, vertexmesh = rsurface.array_batchvertexmesh;j < rsurface.batchnumvertices;j++, vertexmesh++)
12200                                 Vector2Copy(rsurface.batchtexcoordtexture2f + 2*j, vertexmesh->texcoordtexture2f);
12201                 if ((batchneed & BATCHNEED_VERTEXMESH_LIGHTMAP) && rsurface.batchtexcoordlightmap2f)
12202                         for (j = 0, vertexmesh = rsurface.array_batchvertexmesh;j < rsurface.batchnumvertices;j++, vertexmesh++)
12203                                 Vector2Copy(rsurface.batchtexcoordlightmap2f + 2*j, vertexmesh->texcoordlightmap2f);
12204         }
12205
12206         if (needsupdate & batchneed & BATCHNEED_VERTEXPOSITION)
12207         {
12208                 // convert the modified arrays to vertex structs
12209                 rsurface.batchvertexposition = rsurface.array_batchvertexposition;
12210                 rsurface.batchvertexpositionbuffer = NULL;
12211                 if (sizeof(r_vertexposition_t) == sizeof(float[3]))
12212                         memcpy(rsurface.array_batchvertexposition, rsurface.batchvertex3f, rsurface.batchnumvertices * sizeof(r_vertexposition_t));
12213                 else
12214                         for (j = 0, vertexposition = rsurface.array_batchvertexposition;j < rsurface.batchnumvertices;j++, vertexposition++)
12215                                 VectorCopy(rsurface.batchvertex3f + 3*j, vertexposition->vertex3f);
12216         }
12217 }
12218
12219 void RSurf_DrawBatch(void)
12220 {
12221         // sometimes a zero triangle surface (usually a degenerate patch) makes it
12222         // through the pipeline, killing it earlier in the pipeline would have
12223         // per-surface overhead rather than per-batch overhead, so it's best to
12224         // reject it here, before it hits glDraw.
12225         if (rsurface.batchnumtriangles == 0)
12226                 return;
12227 #if 0
12228         // batch debugging code
12229         if (r_test.integer && rsurface.entity == r_refdef.scene.worldentity && rsurface.batchvertex3f == r_refdef.scene.worldentity->model->surfmesh.data_vertex3f)
12230         {
12231                 int i;
12232                 int j;
12233                 int c;
12234                 const int *e;
12235                 e = rsurface.batchelement3i + rsurface.batchfirsttriangle*3;
12236                 for (i = 0;i < rsurface.batchnumtriangles*3;i++)
12237                 {
12238                         c = e[i];
12239                         for (j = 0;j < rsurface.entity->model->num_surfaces;j++)
12240                         {
12241                                 if (c >= rsurface.modelsurfaces[j].num_firstvertex && c < (rsurface.modelsurfaces[j].num_firstvertex + rsurface.modelsurfaces[j].num_vertices))
12242                                 {
12243                                         if (rsurface.modelsurfaces[j].texture != rsurface.texture)
12244                                                 Sys_Error("RSurf_DrawBatch: index %i uses different texture (%s) than surface %i which it belongs to (which uses %s)\n", c, rsurface.texture->name, j, rsurface.modelsurfaces[j].texture->name);
12245                                         break;
12246                                 }
12247                         }
12248                 }
12249         }
12250 #endif
12251         R_Mesh_Draw(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchfirsttriangle, rsurface.batchnumtriangles, rsurface.batchelement3i, rsurface.batchelement3i_indexbuffer, rsurface.batchelement3i_bufferoffset, rsurface.batchelement3s, rsurface.batchelement3s_indexbuffer, rsurface.batchelement3s_bufferoffset);
12252 }
12253
12254 static int RSurf_FindWaterPlaneForSurface(const msurface_t *surface)
12255 {
12256         // pick the closest matching water plane
12257         int planeindex, vertexindex, bestplaneindex = -1;
12258         float d, bestd;
12259         vec3_t vert;
12260         const float *v;
12261         r_waterstate_waterplane_t *p;
12262         qboolean prepared = false;
12263         bestd = 0;
12264         for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
12265         {
12266                 if(p->camera_entity != rsurface.texture->camera_entity)
12267                         continue;
12268                 d = 0;
12269                 if(!prepared)
12270                 {
12271                         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX, 1, &surface);
12272                         prepared = true;
12273                         if(rsurface.batchnumvertices == 0)
12274                                 break;
12275                 }
12276                 for (vertexindex = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3;vertexindex < rsurface.batchnumvertices;vertexindex++, v += 3)
12277                 {
12278                         Matrix4x4_Transform(&rsurface.matrix, v, vert);
12279                         d += fabs(PlaneDiff(vert, &p->plane));
12280                 }
12281                 if (bestd > d || bestplaneindex < 0)
12282                 {
12283                         bestd = d;
12284                         bestplaneindex = planeindex;
12285                 }
12286         }
12287         return bestplaneindex;
12288         // NOTE: this MAY return a totally unrelated water plane; we can ignore
12289         // this situation though, as it might be better to render single larger
12290         // batches with useless stuff (backface culled for example) than to
12291         // render multiple smaller batches
12292 }
12293
12294 static void RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray(void)
12295 {
12296         int i;
12297         for (i = 0;i < rsurface.batchnumvertices;i++)
12298                 Vector4Set(rsurface.array_passcolor4f + 4*i, 0.5f, 0.5f, 0.5f, 1.0f);
12299         rsurface.passcolor4f = rsurface.array_passcolor4f;
12300         rsurface.passcolor4f_vertexbuffer = 0;
12301         rsurface.passcolor4f_bufferoffset = 0;
12302 }
12303
12304 static void RSurf_DrawBatch_GL11_ApplyFog(void)
12305 {
12306         int i;
12307         float f;
12308         const float *v;
12309         const float *c;
12310         float *c2;
12311         if (rsurface.passcolor4f)
12312         {
12313                 // generate color arrays
12314                 for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4, c2 = rsurface.array_passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, c += 4, c2 += 4)
12315                 {
12316                         f = RSurf_FogVertex(v);
12317                         c2[0] = c[0] * f;
12318                         c2[1] = c[1] * f;
12319                         c2[2] = c[2] * f;
12320                         c2[3] = c[3];
12321                 }
12322         }
12323         else
12324         {
12325                 for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, c2 = rsurface.array_passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, c2 += 4)
12326                 {
12327                         f = RSurf_FogVertex(v);
12328                         c2[0] = f;
12329                         c2[1] = f;
12330                         c2[2] = f;
12331                         c2[3] = 1;
12332                 }
12333         }
12334         rsurface.passcolor4f = rsurface.array_passcolor4f;
12335         rsurface.passcolor4f_vertexbuffer = 0;
12336         rsurface.passcolor4f_bufferoffset = 0;
12337 }
12338
12339 static void RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors(void)
12340 {
12341         int i;
12342         float f;
12343         const float *v;
12344         const float *c;
12345         float *c2;
12346         if (!rsurface.passcolor4f)
12347                 return;
12348         for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4, c2 = rsurface.array_passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, c += 4, c2 += 4)
12349         {
12350                 f = RSurf_FogVertex(v);
12351                 c2[0] = c[0] * f + r_refdef.fogcolor[0] * (1 - f);
12352                 c2[1] = c[1] * f + r_refdef.fogcolor[1] * (1 - f);
12353                 c2[2] = c[2] * f + r_refdef.fogcolor[2] * (1 - f);
12354                 c2[3] = c[3];
12355         }
12356         rsurface.passcolor4f = rsurface.array_passcolor4f;
12357         rsurface.passcolor4f_vertexbuffer = 0;
12358         rsurface.passcolor4f_bufferoffset = 0;
12359 }
12360
12361 static void RSurf_DrawBatch_GL11_ApplyColor(float r, float g, float b, float a)
12362 {
12363         int i;
12364         const float *c;
12365         float *c2;
12366         if (!rsurface.passcolor4f)
12367                 return;
12368         for (i = 0, c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4, c2 = rsurface.array_passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, c += 4, c2 += 4)
12369         {
12370                 c2[0] = c[0] * r;
12371                 c2[1] = c[1] * g;
12372                 c2[2] = c[2] * b;
12373                 c2[3] = c[3] * a;
12374         }
12375         rsurface.passcolor4f = rsurface.array_passcolor4f;
12376         rsurface.passcolor4f_vertexbuffer = 0;
12377         rsurface.passcolor4f_bufferoffset = 0;
12378 }
12379
12380 static void RSurf_DrawBatch_GL11_ApplyAmbient(void)
12381 {
12382         int i;
12383         const float *c;
12384         float *c2;
12385         if (!rsurface.passcolor4f)
12386                 return;
12387         for (i = 0, c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4, c2 = rsurface.array_passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, c += 4, c2 += 4)
12388         {
12389                 c2[0] = c[0] + r_refdef.scene.ambient;
12390                 c2[1] = c[1] + r_refdef.scene.ambient;
12391                 c2[2] = c[2] + r_refdef.scene.ambient;
12392                 c2[3] = c[3];
12393         }
12394         rsurface.passcolor4f = rsurface.array_passcolor4f;
12395         rsurface.passcolor4f_vertexbuffer = 0;
12396         rsurface.passcolor4f_bufferoffset = 0;
12397 }
12398
12399 static void RSurf_DrawBatch_GL11_Lightmap(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
12400 {
12401         // TODO: optimize
12402         rsurface.passcolor4f = NULL;
12403         rsurface.passcolor4f_vertexbuffer = 0;
12404         rsurface.passcolor4f_bufferoffset = 0;
12405         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog();
12406         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
12407         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
12408         GL_Color(r, g, b, a);
12409         R_Mesh_TexBind(0, rsurface.lightmaptexture);
12410         RSurf_DrawBatch();
12411 }
12412
12413 static void RSurf_DrawBatch_GL11_Unlit(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
12414 {
12415         // TODO: optimize applyfog && applycolor case
12416         // just apply fog if necessary, and tint the fog color array if necessary
12417         rsurface.passcolor4f = NULL;
12418         rsurface.passcolor4f_vertexbuffer = 0;
12419         rsurface.passcolor4f_bufferoffset = 0;
12420         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog();
12421         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
12422         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
12423         GL_Color(r, g, b, a);
12424         RSurf_DrawBatch();
12425 }
12426
12427 static void RSurf_DrawBatch_GL11_VertexColor(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
12428 {
12429         // TODO: optimize
12430         rsurface.passcolor4f = rsurface.batchlightmapcolor4f;
12431         rsurface.passcolor4f_vertexbuffer = rsurface.batchlightmapcolor4f_vertexbuffer;
12432         rsurface.passcolor4f_bufferoffset = rsurface.batchlightmapcolor4f_bufferoffset;
12433         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog();
12434         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
12435         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
12436         GL_Color(r, g, b, a);
12437         RSurf_DrawBatch();
12438 }
12439
12440 static void RSurf_DrawBatch_GL11_ClampColor(void)
12441 {
12442         int i;
12443         const float *c1;
12444         float *c2;
12445         if (!rsurface.passcolor4f)
12446                 return;
12447         for (i = 0, c1 = rsurface.passcolor4f + 4*rsurface.batchfirstvertex, c2 = rsurface.array_passcolor4f + 4*rsurface.batchfirstvertex;i < rsurface.batchnumvertices;i++, c1 += 4, c2 += 4)
12448         {
12449                 c2[0] = bound(0.0f, c1[0], 1.0f);
12450                 c2[1] = bound(0.0f, c1[1], 1.0f);
12451                 c2[2] = bound(0.0f, c1[2], 1.0f);
12452                 c2[3] = bound(0.0f, c1[3], 1.0f);
12453         }
12454 }
12455
12456 static void RSurf_DrawBatch_GL11_ApplyFakeLight(void)
12457 {
12458         int i;
12459         float f;
12460         const float *v;
12461         const float *n;
12462         float *c;
12463         //vec3_t eyedir;
12464
12465         // fake shading
12466         for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, n = rsurface.batchnormal3f + rsurface.batchfirstvertex * 3, c = rsurface.array_passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, n += 3, c += 4)
12467         {
12468                 f = -DotProduct(r_refdef.view.forward, n);
12469                 f = max(0, f);
12470                 f = f * 0.85 + 0.15; // work around so stuff won't get black
12471                 f *= r_refdef.lightmapintensity;
12472                 Vector4Set(c, f, f, f, 1);
12473         }
12474
12475         rsurface.passcolor4f = rsurface.array_passcolor4f;
12476         rsurface.passcolor4f_vertexbuffer = 0;
12477         rsurface.passcolor4f_bufferoffset = 0;
12478 }
12479
12480 static void RSurf_DrawBatch_GL11_FakeLight(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
12481 {
12482         RSurf_DrawBatch_GL11_ApplyFakeLight();
12483         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog();
12484         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
12485         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
12486         GL_Color(r, g, b, a);
12487         RSurf_DrawBatch();
12488 }
12489
12490 static void RSurf_DrawBatch_GL11_ApplyVertexShade(float *r, float *g, float *b, float *a, qboolean *applycolor)
12491 {
12492         int i;
12493         float f;
12494         float alpha;
12495         const float *v;
12496         const float *n;
12497         float *c;
12498         vec3_t ambientcolor;
12499         vec3_t diffusecolor;
12500         vec3_t lightdir;
12501         // TODO: optimize
12502         // model lighting
12503         VectorCopy(rsurface.modellight_lightdir, lightdir);
12504         f = 0.5f * r_refdef.lightmapintensity;
12505         ambientcolor[0] = rsurface.modellight_ambient[0] * *r * f;
12506         ambientcolor[1] = rsurface.modellight_ambient[1] * *g * f;
12507         ambientcolor[2] = rsurface.modellight_ambient[2] * *b * f;
12508         diffusecolor[0] = rsurface.modellight_diffuse[0] * *r * f;
12509         diffusecolor[1] = rsurface.modellight_diffuse[1] * *g * f;
12510         diffusecolor[2] = rsurface.modellight_diffuse[2] * *b * f;
12511         alpha = *a;
12512         if (VectorLength2(diffusecolor) > 0)
12513         {
12514                 // q3-style directional shading
12515                 for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, n = rsurface.batchnormal3f + rsurface.batchfirstvertex * 3, c = rsurface.array_passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, n += 3, c += 4)
12516                 {
12517                         if ((f = DotProduct(n, lightdir)) > 0)
12518                                 VectorMA(ambientcolor, f, diffusecolor, c);
12519                         else
12520                                 VectorCopy(ambientcolor, c);
12521                         c[3] = alpha;
12522                 }
12523                 *r = 1;
12524                 *g = 1;
12525                 *b = 1;
12526                 *a = 1;
12527                 rsurface.passcolor4f = rsurface.array_passcolor4f;
12528                 rsurface.passcolor4f_vertexbuffer = 0;
12529                 rsurface.passcolor4f_bufferoffset = 0;
12530                 *applycolor = false;
12531         }
12532         else
12533         {
12534                 *r = ambientcolor[0];
12535                 *g = ambientcolor[1];
12536                 *b = ambientcolor[2];
12537                 rsurface.passcolor4f = NULL;
12538                 rsurface.passcolor4f_vertexbuffer = 0;
12539                 rsurface.passcolor4f_bufferoffset = 0;
12540         }
12541 }
12542
12543 static void RSurf_DrawBatch_GL11_VertexShade(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
12544 {
12545         RSurf_DrawBatch_GL11_ApplyVertexShade(&r, &g, &b, &a, &applycolor);
12546         if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog();
12547         if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
12548         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
12549         GL_Color(r, g, b, a);
12550         RSurf_DrawBatch();
12551 }
12552
12553 static void RSurf_DrawBatch_GL11_MakeFogColor(float r, float g, float b, float a)
12554 {
12555         int i;
12556         float f;
12557         const float *v;
12558         float *c;
12559         for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, c = rsurface.array_passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, c += 4)
12560         {
12561                 f = 1 - RSurf_FogVertex(v);
12562                 c[0] = r;
12563                 c[1] = g;
12564                 c[2] = b;
12565                 c[3] = f * a;
12566         }
12567 }
12568
12569 void RSurf_SetupDepthAndCulling(void)
12570 {
12571         // submodels are biased to avoid z-fighting with world surfaces that they
12572         // may be exactly overlapping (avoids z-fighting artifacts on certain
12573         // doors and things in Quake maps)
12574         GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
12575         GL_PolygonOffset(rsurface.basepolygonfactor + rsurface.texture->biaspolygonfactor, rsurface.basepolygonoffset + rsurface.texture->biaspolygonoffset);
12576         GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
12577         GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_refdef.view.cullface_back);
12578 }
12579
12580 static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, const msurface_t **texturesurfacelist)
12581 {
12582         // transparent sky would be ridiculous
12583         if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
12584                 return;
12585         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
12586         skyrenderlater = true;
12587         RSurf_SetupDepthAndCulling();
12588         GL_DepthMask(true);
12589         // LordHavoc: HalfLife maps have freaky skypolys so don't use
12590         // skymasking on them, and Quake3 never did sky masking (unlike
12591         // software Quake and software Quake2), so disable the sky masking
12592         // in Quake3 maps as it causes problems with q3map2 sky tricks,
12593         // and skymasking also looks very bad when noclipping outside the
12594         // level, so don't use it then either.
12595         if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_refdef.viewcache.world_novis)
12596         {
12597                 R_Mesh_ResetTextureState();
12598                 if (skyrendermasked)
12599                 {
12600                         R_SetupShader_DepthOrShadow();
12601                         // depth-only (masking)
12602                         GL_ColorMask(0,0,0,0);
12603                         // just to make sure that braindead drivers don't draw
12604                         // anything despite that colormask...
12605                         GL_BlendFunc(GL_ZERO, GL_ONE);
12606                         RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXPOSITION | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12607                         R_Mesh_PrepareVertices_Position(rsurface.batchnumvertices, rsurface.batchvertexposition, rsurface.batchvertexpositionbuffer);
12608                 }
12609                 else
12610                 {
12611                         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
12612                         // fog sky
12613                         GL_BlendFunc(GL_ONE, GL_ZERO);
12614                         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12615                         GL_Color(r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2], 1);
12616                         R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, NULL, NULL);
12617                 }
12618                 RSurf_DrawBatch();
12619                 if (skyrendermasked)
12620                         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
12621         }
12622         R_Mesh_ResetTextureState();
12623         GL_Color(1, 1, 1, 1);
12624 }
12625
12626 extern rtexture_t *r_shadow_prepasslightingdiffusetexture;
12627 extern rtexture_t *r_shadow_prepasslightingspeculartexture;
12628 static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
12629 {
12630         if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA)))
12631                 return;
12632         if (prepass)
12633         {
12634                 // render screenspace normalmap to texture
12635                 GL_DepthMask(true);
12636                 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_DEFERREDGEOMETRY, texturenumsurfaces, texturesurfacelist, NULL);
12637                 RSurf_DrawBatch();
12638                 return;
12639         }
12640
12641         // bind lightmap texture
12642
12643         // water/refraction/reflection/camera surfaces have to be handled specially
12644         if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_CAMERA | MATERIALFLAG_REFLECTION)))
12645         {
12646                 int start, end, startplaneindex;
12647                 for (start = 0;start < texturenumsurfaces;start = end)
12648                 {
12649                         startplaneindex = RSurf_FindWaterPlaneForSurface(texturesurfacelist[start]);
12650                         if(startplaneindex < 0)
12651                         {
12652                                 // this happens if the plane e.g. got backface culled and thus didn't get a water plane. We can just ignore this.
12653                                 // Con_Printf("No matching water plane for surface with material flags 0x%08x - PLEASE DEBUG THIS\n", rsurface.texture->currentmaterialflags);
12654                                 end = start + 1;
12655                                 continue;
12656                         }
12657                         for (end = start + 1;end < texturenumsurfaces && startplaneindex == RSurf_FindWaterPlaneForSurface(texturesurfacelist[end]);end++)
12658                                 ;
12659                         // now that we have a batch using the same planeindex, render it
12660                         if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_CAMERA)))
12661                         {
12662                                 // render water or distortion background
12663                                 GL_DepthMask(true);
12664                                 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BACKGROUND, end-start, texturesurfacelist + start, (void *)(r_waterstate.waterplanes + startplaneindex));
12665                                 RSurf_DrawBatch();
12666                                 // blend surface on top
12667                                 GL_DepthMask(false);
12668                                 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE, end-start, texturesurfacelist + start, NULL);
12669                                 RSurf_DrawBatch();
12670                         }
12671                         else if ((rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION))
12672                         {
12673                                 // render surface with reflection texture as input
12674                                 GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED));
12675                                 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE, end-start, texturesurfacelist + start, (void *)(r_waterstate.waterplanes + startplaneindex));
12676                                 RSurf_DrawBatch();
12677                         }
12678                 }
12679                 return;
12680         }
12681
12682         // render surface batch normally
12683         GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED));
12684         R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE, texturenumsurfaces, texturesurfacelist, NULL);
12685         RSurf_DrawBatch();
12686 }
12687
12688 static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
12689 {
12690         // OpenGL 1.3 path - anything not completely ancient
12691         qboolean applycolor;
12692         qboolean applyfog;
12693         int layerindex;
12694         const texturelayer_t *layer;
12695         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | ((!rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) ? BATCHNEED_ARRAY_VERTEXCOLOR : 0) | BATCHNEED_ARRAY_TEXCOORD | (rsurface.modeltexcoordlightmap2f ? BATCHNEED_ARRAY_LIGHTMAP : 0) | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12696         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
12697
12698         for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
12699         {
12700                 vec4_t layercolor;
12701                 int layertexrgbscale;
12702                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
12703                 {
12704                         if (layerindex == 0)
12705                                 GL_AlphaTest(true);
12706                         else
12707                         {
12708                                 GL_AlphaTest(false);
12709                                 GL_DepthFunc(GL_EQUAL);
12710                         }
12711                 }
12712                 GL_DepthMask(layer->depthmask && writedepth);
12713                 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
12714                 if (layer->color[0] > 2 || layer->color[1] > 2 || layer->color[2] > 2)
12715                 {
12716                         layertexrgbscale = 4;
12717                         VectorScale(layer->color, 0.25f, layercolor);
12718                 }
12719                 else if (layer->color[0] > 1 || layer->color[1] > 1 || layer->color[2] > 1)
12720                 {
12721                         layertexrgbscale = 2;
12722                         VectorScale(layer->color, 0.5f, layercolor);
12723                 }
12724                 else
12725                 {
12726                         layertexrgbscale = 1;
12727                         VectorScale(layer->color, 1.0f, layercolor);
12728                 }
12729                 layercolor[3] = layer->color[3];
12730                 applycolor = layercolor[0] != 1 || layercolor[1] != 1 || layercolor[2] != 1 || layercolor[3] != 1;
12731                 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, 0, 0);
12732                 applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
12733                 switch (layer->type)
12734                 {
12735                 case TEXTURELAYERTYPE_LITTEXTURE:
12736                         // single-pass lightmapped texture with 2x rgbscale
12737                         R_Mesh_TexBind(0, r_texture_white);
12738                         R_Mesh_TexMatrix(0, NULL);
12739                         R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
12740                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordlightmap2f_vertexbuffer, rsurface.batchtexcoordlightmap2f_bufferoffset);
12741                         R_Mesh_TexBind(1, layer->texture);
12742                         R_Mesh_TexMatrix(1, &layer->texmatrix);
12743                         R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
12744                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
12745                         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
12746                                 RSurf_DrawBatch_GL11_VertexShade(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
12747                         else if (FAKELIGHT_ENABLED)
12748                                 RSurf_DrawBatch_GL11_FakeLight(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
12749                         else if (rsurface.uselightmaptexture)
12750                                 RSurf_DrawBatch_GL11_Lightmap(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
12751                         else
12752                                 RSurf_DrawBatch_GL11_VertexColor(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
12753                         break;
12754                 case TEXTURELAYERTYPE_TEXTURE:
12755                         // singletexture unlit texture with transparency support
12756                         R_Mesh_TexBind(0, layer->texture);
12757                         R_Mesh_TexMatrix(0, &layer->texmatrix);
12758                         R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
12759                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
12760                         R_Mesh_TexBind(1, 0);
12761                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, 0, 0);
12762                         RSurf_DrawBatch_GL11_Unlit(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
12763                         break;
12764                 case TEXTURELAYERTYPE_FOG:
12765                         // singletexture fogging
12766                         if (layer->texture)
12767                         {
12768                                 R_Mesh_TexBind(0, layer->texture);
12769                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
12770                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
12771                                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
12772                         }
12773                         else
12774                         {
12775                                 R_Mesh_TexBind(0, 0);
12776                                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, 0, 0);
12777                         }
12778                         R_Mesh_TexBind(1, 0);
12779                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, 0, 0);
12780                         // generate a color array for the fog pass
12781                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.array_passcolor4f, 0, 0);
12782                         RSurf_DrawBatch_GL11_MakeFogColor(layercolor[0], layercolor[1], layercolor[2], layercolor[3]);
12783                         RSurf_DrawBatch();
12784                         break;
12785                 default:
12786                         Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
12787                 }
12788         }
12789         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
12790         {
12791                 GL_DepthFunc(GL_LEQUAL);
12792                 GL_AlphaTest(false);
12793         }
12794 }
12795
12796 static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
12797 {
12798         // OpenGL 1.1 - crusty old voodoo path
12799         qboolean applyfog;
12800         int layerindex;
12801         const texturelayer_t *layer;
12802         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | ((!rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) ? BATCHNEED_ARRAY_VERTEXCOLOR : 0) | BATCHNEED_ARRAY_TEXCOORD | (rsurface.modeltexcoordlightmap2f ? BATCHNEED_ARRAY_LIGHTMAP : 0) | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12803         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
12804
12805         for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
12806         {
12807                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
12808                 {
12809                         if (layerindex == 0)
12810                                 GL_AlphaTest(true);
12811                         else
12812                         {
12813                                 GL_AlphaTest(false);
12814                                 GL_DepthFunc(GL_EQUAL);
12815                         }
12816                 }
12817                 GL_DepthMask(layer->depthmask && writedepth);
12818                 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
12819                 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, 0, 0);
12820                 applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
12821                 switch (layer->type)
12822                 {
12823                 case TEXTURELAYERTYPE_LITTEXTURE:
12824                         if (layer->blendfunc1 == GL_ONE && layer->blendfunc2 == GL_ZERO)
12825                         {
12826                                 // two-pass lit texture with 2x rgbscale
12827                                 // first the lightmap pass
12828                                 R_Mesh_TexBind(0, r_texture_white);
12829                                 R_Mesh_TexMatrix(0, NULL);
12830                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
12831                                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordlightmap2f_vertexbuffer, rsurface.batchtexcoordlightmap2f_bufferoffset);
12832                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
12833                                         RSurf_DrawBatch_GL11_VertexShade(1, 1, 1, 1, false, false);
12834                                 else if (FAKELIGHT_ENABLED)
12835                                         RSurf_DrawBatch_GL11_FakeLight(1, 1, 1, 1, false, false);
12836                                 else if (rsurface.uselightmaptexture)
12837                                         RSurf_DrawBatch_GL11_Lightmap(1, 1, 1, 1, false, false);
12838                                 else
12839                                         RSurf_DrawBatch_GL11_VertexColor(1, 1, 1, 1, false, false);
12840                                 // then apply the texture to it
12841                                 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
12842                                 R_Mesh_TexBind(0, layer->texture);
12843                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
12844                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
12845                                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
12846                                 RSurf_DrawBatch_GL11_Unlit(layer->color[0] * 0.5f, layer->color[1] * 0.5f, layer->color[2] * 0.5f, layer->color[3], layer->color[0] != 2 || layer->color[1] != 2 || layer->color[2] != 2 || layer->color[3] != 1, false);
12847                         }
12848                         else
12849                         {
12850                                 // single pass vertex-lighting-only texture with 1x rgbscale and transparency support
12851                                 R_Mesh_TexBind(0, layer->texture);
12852                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
12853                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
12854                                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
12855                                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
12856                                         RSurf_DrawBatch_GL11_VertexShade(layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
12857                                 else
12858                                         RSurf_DrawBatch_GL11_VertexColor(layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
12859                         }
12860                         break;
12861                 case TEXTURELAYERTYPE_TEXTURE:
12862                         // singletexture unlit texture with transparency support
12863                         R_Mesh_TexBind(0, layer->texture);
12864                         R_Mesh_TexMatrix(0, &layer->texmatrix);
12865                         R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
12866                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
12867                         RSurf_DrawBatch_GL11_Unlit(layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
12868                         break;
12869                 case TEXTURELAYERTYPE_FOG:
12870                         // singletexture fogging
12871                         if (layer->texture)
12872                         {
12873                                 R_Mesh_TexBind(0, layer->texture);
12874                                 R_Mesh_TexMatrix(0, &layer->texmatrix);
12875                                 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
12876                                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
12877                         }
12878                         else
12879                         {
12880                                 R_Mesh_TexBind(0, 0);
12881                                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, 0, 0);
12882                         }
12883                         // generate a color array for the fog pass
12884                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.array_passcolor4f, 0, 0);
12885                         RSurf_DrawBatch_GL11_MakeFogColor(layer->color[0], layer->color[1], layer->color[2], layer->color[3]);
12886                         RSurf_DrawBatch();
12887                         break;
12888                 default:
12889                         Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
12890                 }
12891         }
12892         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
12893         {
12894                 GL_DepthFunc(GL_LEQUAL);
12895                 GL_AlphaTest(false);
12896         }
12897 }
12898
12899 static void R_DrawTextureSurfaceList_ShowSurfaces(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
12900 {
12901         int vi;
12902         int j;
12903         r_vertexgeneric_t *batchvertex;
12904         float c[4];
12905
12906         GL_AlphaTest(false);
12907 //      R_Mesh_ResetTextureState();
12908         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
12909
12910         if(rsurface.texture && rsurface.texture->currentskinframe)
12911         {
12912                 memcpy(c, rsurface.texture->currentskinframe->avgcolor, sizeof(c));
12913                 c[3] *= rsurface.texture->currentalpha;
12914         }
12915         else
12916         {
12917                 c[0] = 1;
12918                 c[1] = 0;
12919                 c[2] = 1;
12920                 c[3] = 1;
12921         }
12922
12923         if (rsurface.texture->pantstexture || rsurface.texture->shirttexture)
12924         {
12925                 c[0] = 0.5 * (rsurface.colormap_pantscolor[0] * 0.3 + rsurface.colormap_shirtcolor[0] * 0.7);
12926                 c[1] = 0.5 * (rsurface.colormap_pantscolor[1] * 0.3 + rsurface.colormap_shirtcolor[1] * 0.7);
12927                 c[2] = 0.5 * (rsurface.colormap_pantscolor[2] * 0.3 + rsurface.colormap_shirtcolor[2] * 0.7);
12928         }
12929
12930         // brighten it up (as texture value 127 means "unlit")
12931         c[0] *= 2 * r_refdef.view.colorscale;
12932         c[1] *= 2 * r_refdef.view.colorscale;
12933         c[2] *= 2 * r_refdef.view.colorscale;
12934
12935         if(rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERALPHA)
12936                 c[3] *= r_wateralpha.value;
12937
12938         if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHA && c[3] != 1)
12939         {
12940                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
12941                 GL_DepthMask(false);
12942         }
12943         else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
12944         {
12945                 GL_BlendFunc(GL_ONE, GL_ONE);
12946                 GL_DepthMask(false);
12947         }
12948         else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
12949         {
12950                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // can't do alpha test without texture, so let's blend instead
12951                 GL_DepthMask(false);
12952         }
12953         else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
12954         {
12955                 GL_BlendFunc(rsurface.texture->customblendfunc[0], rsurface.texture->customblendfunc[1]);
12956                 GL_DepthMask(false);
12957         }
12958         else
12959         {
12960                 GL_BlendFunc(GL_ONE, GL_ZERO);
12961                 GL_DepthMask(writedepth);
12962         }
12963
12964         if (r_showsurfaces.integer == 3)
12965         {
12966                 rsurface.passcolor4f = NULL;
12967
12968                 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
12969                 {
12970                         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12971
12972                         rsurface.passcolor4f = NULL;
12973                         rsurface.passcolor4f_vertexbuffer = 0;
12974                         rsurface.passcolor4f_bufferoffset = 0;
12975                 }
12976                 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
12977                 {
12978                         qboolean applycolor = true;
12979                         float one = 1.0;
12980
12981                         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12982
12983                         r_refdef.lightmapintensity = 1;
12984                         RSurf_DrawBatch_GL11_ApplyVertexShade(&one, &one, &one, &one, &applycolor);
12985                         r_refdef.lightmapintensity = 0; // we're in showsurfaces, after all
12986                 }
12987                 else if (FAKELIGHT_ENABLED)
12988                 {
12989                         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12990
12991                         r_refdef.lightmapintensity = r_fakelight_intensity.value;
12992                         RSurf_DrawBatch_GL11_ApplyFakeLight();
12993                         r_refdef.lightmapintensity = 0; // we're in showsurfaces, after all
12994                 }
12995                 else
12996                 {
12997                         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_VERTEXCOLOR | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
12998
12999                         rsurface.passcolor4f = rsurface.batchlightmapcolor4f;
13000                         rsurface.passcolor4f_vertexbuffer = rsurface.batchlightmapcolor4f_vertexbuffer;
13001                         rsurface.passcolor4f_bufferoffset = rsurface.batchlightmapcolor4f_bufferoffset;
13002                 }
13003
13004                 if(!rsurface.passcolor4f)
13005                         RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray();
13006
13007                 RSurf_DrawBatch_GL11_ApplyAmbient();
13008                 RSurf_DrawBatch_GL11_ApplyColor(c[0], c[1], c[2], c[3]);
13009                 if(r_refdef.fogenabled)
13010                         RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors();
13011                 RSurf_DrawBatch_GL11_ClampColor();
13012
13013                 R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, rsurface.passcolor4f, NULL);
13014                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
13015                 RSurf_DrawBatch();
13016         }
13017         else if (!r_refdef.view.showdebug)
13018         {
13019                 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
13020                 batchvertex = R_Mesh_PrepareVertices_Generic_Lock(rsurface.batchnumvertices);
13021                 for (j = 0, vi = rsurface.batchfirstvertex;j < rsurface.batchnumvertices;j++, vi++)
13022                 {
13023                         VectorCopy(rsurface.batchvertex3f + 3*vi, batchvertex[vi].vertex3f);
13024                         Vector4Set(batchvertex[vi].color4ub, 0, 0, 0, 255);
13025                 }
13026                 R_Mesh_PrepareVertices_Generic_Unlock();
13027                 RSurf_DrawBatch();
13028         }
13029         else if (r_showsurfaces.integer == 4)
13030         {
13031                 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
13032                 batchvertex = R_Mesh_PrepareVertices_Generic_Lock(rsurface.batchnumvertices);
13033                 for (j = 0, vi = rsurface.batchfirstvertex;j < rsurface.batchnumvertices;j++, vi++)
13034                 {
13035                         unsigned char c = vi << 3;
13036                         VectorCopy(rsurface.batchvertex3f + 3*vi, batchvertex[vi].vertex3f);
13037                         Vector4Set(batchvertex[vi].color4ub, c, c, c, 255);
13038                 }
13039                 R_Mesh_PrepareVertices_Generic_Unlock();
13040                 RSurf_DrawBatch();
13041         }
13042         else if (r_showsurfaces.integer == 2)
13043         {
13044                 const int *e;
13045                 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
13046                 batchvertex = R_Mesh_PrepareVertices_Generic_Lock(3*rsurface.batchnumtriangles);
13047                 for (j = 0, e = rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle;j < rsurface.batchnumtriangles;j++, e += 3)
13048                 {
13049                         unsigned char c = (j + rsurface.batchfirsttriangle) << 3;
13050                         VectorCopy(rsurface.batchvertex3f + 3*e[0], batchvertex[j*3+0].vertex3f);
13051                         VectorCopy(rsurface.batchvertex3f + 3*e[1], batchvertex[j*3+1].vertex3f);
13052                         VectorCopy(rsurface.batchvertex3f + 3*e[2], batchvertex[j*3+2].vertex3f);
13053                         Vector4Set(batchvertex[j*3+0].color4ub, c, c, c, 255);
13054                         Vector4Set(batchvertex[j*3+1].color4ub, c, c, c, 255);
13055                         Vector4Set(batchvertex[j*3+2].color4ub, c, c, c, 255);
13056                 }
13057                 R_Mesh_PrepareVertices_Generic_Unlock();
13058                 R_Mesh_Draw(0, rsurface.batchnumtriangles*3, 0, rsurface.batchnumtriangles, NULL, NULL, 0, NULL, NULL, 0);
13059         }
13060         else
13061         {
13062                 int texturesurfaceindex;
13063                 int k;
13064                 const msurface_t *surface;
13065                 unsigned char surfacecolor4ub[4];
13066                 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
13067                 batchvertex = R_Mesh_PrepareVertices_Generic_Lock(rsurface.batchfirstvertex + rsurface.batchnumvertices);
13068                 vi = 0;
13069                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
13070                 {
13071                         surface = texturesurfacelist[texturesurfaceindex];
13072                         k = (int)(((size_t)surface) / sizeof(msurface_t));
13073                         Vector4Set(surfacecolor4ub, (k & 0xF) << 4, (k & 0xF0), (k & 0xF00) >> 4, 255);
13074                         for (j = 0;j < surface->num_vertices;j++)
13075                         {
13076                                 VectorCopy(rsurface.batchvertex3f + 3*vi, batchvertex[vi].vertex3f);
13077                                 Vector4Copy(surfacecolor4ub, batchvertex[vi].color4ub);
13078                                 vi++;
13079                         }
13080                 }
13081                 R_Mesh_PrepareVertices_Generic_Unlock();
13082                 RSurf_DrawBatch();
13083         }
13084 }
13085
13086 static void R_DrawWorldTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
13087 {
13088         CHECKGLERROR
13089         RSurf_SetupDepthAndCulling();
13090         if (r_showsurfaces.integer)
13091         {
13092                 R_DrawTextureSurfaceList_ShowSurfaces(texturenumsurfaces, texturesurfacelist, writedepth);
13093                 return;
13094         }
13095         switch (vid.renderpath)
13096         {
13097         case RENDERPATH_GL20:
13098         case RENDERPATH_CGGL:
13099         case RENDERPATH_D3D9:
13100         case RENDERPATH_D3D10:
13101         case RENDERPATH_D3D11:
13102                 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
13103                 break;
13104         case RENDERPATH_GL13:
13105                 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
13106                 break;
13107         case RENDERPATH_GL11:
13108                 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
13109                 break;
13110         }
13111         CHECKGLERROR
13112 }
13113
13114 static void R_DrawModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
13115 {
13116         CHECKGLERROR
13117         RSurf_SetupDepthAndCulling();
13118         if (r_showsurfaces.integer)
13119         {
13120                 R_DrawTextureSurfaceList_ShowSurfaces(texturenumsurfaces, texturesurfacelist, writedepth);
13121                 return;
13122         }
13123         switch (vid.renderpath)
13124         {
13125         case RENDERPATH_GL20:
13126         case RENDERPATH_CGGL:
13127         case RENDERPATH_D3D9:
13128         case RENDERPATH_D3D10:
13129         case RENDERPATH_D3D11:
13130                 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
13131                 break;
13132         case RENDERPATH_GL13:
13133                 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
13134                 break;
13135         case RENDERPATH_GL11:
13136                 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
13137                 break;
13138         }
13139         CHECKGLERROR
13140 }
13141
13142 static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
13143 {
13144         int i, j;
13145         int texturenumsurfaces, endsurface;
13146         texture_t *texture;
13147         const msurface_t *surface;
13148 #define MAXBATCH_TRANSPARENTSURFACES 256
13149         const msurface_t *texturesurfacelist[MAXBATCH_TRANSPARENTSURFACES];
13150
13151         // if the model is static it doesn't matter what value we give for
13152         // wantnormals and wanttangents, so this logic uses only rules applicable
13153         // to a model, knowing that they are meaningless otherwise
13154         if (ent == r_refdef.scene.worldentity)
13155                 RSurf_ActiveWorldEntity();
13156         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
13157                 RSurf_ActiveModelEntity(ent, false, false, false);
13158         else
13159         {
13160                 switch (vid.renderpath)
13161                 {
13162                 case RENDERPATH_GL20:
13163                 case RENDERPATH_CGGL:
13164                 case RENDERPATH_D3D9:
13165                 case RENDERPATH_D3D10:
13166                 case RENDERPATH_D3D11:
13167                         RSurf_ActiveModelEntity(ent, true, true, false);
13168                         break;
13169                 case RENDERPATH_GL13:
13170                 case RENDERPATH_GL11:
13171                         RSurf_ActiveModelEntity(ent, true, false, false);
13172                         break;
13173                 }
13174         }
13175
13176         if (r_transparentdepthmasking.integer)
13177         {
13178                 qboolean setup = false;
13179                 for (i = 0;i < numsurfaces;i = j)
13180                 {
13181                         j = i + 1;
13182                         surface = rsurface.modelsurfaces + surfacelist[i];
13183                         texture = surface->texture;
13184                         rsurface.texture = R_GetCurrentTexture(texture);
13185                         rsurface.lightmaptexture = NULL;
13186                         rsurface.deluxemaptexture = NULL;
13187                         rsurface.uselightmaptexture = false;
13188                         // scan ahead until we find a different texture
13189                         endsurface = min(i + 1024, numsurfaces);
13190                         texturenumsurfaces = 0;
13191                         texturesurfacelist[texturenumsurfaces++] = surface;
13192                         for (;j < endsurface;j++)
13193                         {
13194                                 surface = rsurface.modelsurfaces + surfacelist[j];
13195                                 if (texture != surface->texture)
13196                                         break;
13197                                 texturesurfacelist[texturenumsurfaces++] = surface;
13198                         }
13199                         if (!(rsurface.texture->currentmaterialflags & MATERIALFLAG_TRANSDEPTH))
13200                                 continue;
13201                         // render the range of surfaces as depth
13202                         if (!setup)
13203                         {
13204                                 setup = true;
13205                                 GL_ColorMask(0,0,0,0);
13206                                 GL_Color(1,1,1,1);
13207                                 GL_DepthTest(true);
13208                                 GL_BlendFunc(GL_ONE, GL_ZERO);
13209                                 GL_DepthMask(true);
13210                                 GL_AlphaTest(false);
13211 //                              R_Mesh_ResetTextureState();
13212                                 R_SetupShader_DepthOrShadow();
13213                         }
13214                         RSurf_SetupDepthAndCulling();
13215                         RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXPOSITION, texturenumsurfaces, texturesurfacelist);
13216                         R_Mesh_PrepareVertices_Position(rsurface.batchnumvertices, rsurface.batchvertexposition, rsurface.batchvertexpositionbuffer);
13217                         RSurf_DrawBatch();
13218                 }
13219                 if (setup)
13220                         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
13221         }
13222
13223         for (i = 0;i < numsurfaces;i = j)
13224         {
13225                 j = i + 1;
13226                 surface = rsurface.modelsurfaces + surfacelist[i];
13227                 texture = surface->texture;
13228                 rsurface.texture = R_GetCurrentTexture(texture);
13229                 // scan ahead until we find a different texture
13230                 endsurface = min(i + MAXBATCH_TRANSPARENTSURFACES, numsurfaces);
13231                 texturenumsurfaces = 0;
13232                 texturesurfacelist[texturenumsurfaces++] = surface;
13233                 if(FAKELIGHT_ENABLED)
13234                 {
13235                         rsurface.lightmaptexture = NULL;
13236                         rsurface.deluxemaptexture = NULL;
13237                         rsurface.uselightmaptexture = false;
13238                         for (;j < endsurface;j++)
13239                         {
13240                                 surface = rsurface.modelsurfaces + surfacelist[j];
13241                                 if (texture != surface->texture)
13242                                         break;
13243                                 texturesurfacelist[texturenumsurfaces++] = surface;
13244                         }
13245                 }
13246                 else
13247                 {
13248                         rsurface.lightmaptexture = surface->lightmaptexture;
13249                         rsurface.deluxemaptexture = surface->deluxemaptexture;
13250                         rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
13251                         for (;j < endsurface;j++)
13252                         {
13253                                 surface = rsurface.modelsurfaces + surfacelist[j];
13254                                 if (texture != surface->texture || rsurface.lightmaptexture != surface->lightmaptexture)
13255                                         break;
13256                                 texturesurfacelist[texturenumsurfaces++] = surface;
13257                         }
13258                 }
13259                 // render the range of surfaces
13260                 if (ent == r_refdef.scene.worldentity)
13261                         R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false, false);
13262                 else
13263                         R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false, false);
13264         }
13265         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
13266         GL_AlphaTest(false);
13267 }
13268
13269 static void R_ProcessTransparentTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, const entity_render_t *queueentity)
13270 {
13271         // transparent surfaces get pushed off into the transparent queue
13272         int surfacelistindex;
13273         const msurface_t *surface;
13274         vec3_t tempcenter, center;
13275         for (surfacelistindex = 0;surfacelistindex < texturenumsurfaces;surfacelistindex++)
13276         {
13277                 surface = texturesurfacelist[surfacelistindex];
13278                 tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f;
13279                 tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f;
13280                 tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f;
13281                 Matrix4x4_Transform(&rsurface.matrix, tempcenter, center);
13282                 if (queueentity->transparent_offset) // transparent offset
13283                 {
13284                         center[0] += r_refdef.view.forward[0]*queueentity->transparent_offset;
13285                         center[1] += r_refdef.view.forward[1]*queueentity->transparent_offset;
13286                         center[2] += r_refdef.view.forward[2]*queueentity->transparent_offset;
13287                 }
13288                 R_MeshQueue_AddTransparent(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_refdef.view.origin : center, R_DrawSurface_TransparentCallback, queueentity, surface - rsurface.modelsurfaces, rsurface.rtlight);
13289         }
13290 }
13291
13292 static void R_DrawTextureSurfaceList_DepthOnly(int texturenumsurfaces, const msurface_t **texturesurfacelist)
13293 {
13294         if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
13295                 return;
13296         if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)))
13297                 return;
13298         RSurf_SetupDepthAndCulling();
13299         RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXPOSITION, texturenumsurfaces, texturesurfacelist);
13300         R_Mesh_PrepareVertices_Position(rsurface.batchnumvertices, rsurface.batchvertexposition, rsurface.batchvertexpositionbuffer);
13301         RSurf_DrawBatch();
13302 }
13303
13304 static void R_ProcessWorldTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, qboolean prepass)
13305 {
13306         const entity_render_t *queueentity = r_refdef.scene.worldentity;
13307         CHECKGLERROR
13308         if (depthonly)
13309                 R_DrawTextureSurfaceList_DepthOnly(texturenumsurfaces, texturesurfacelist);
13310         else if (prepass)
13311         {
13312                 if (!rsurface.texture->currentnumlayers)
13313                         return;
13314                 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
13315                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
13316                 else
13317                         R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
13318         }
13319         else if ((rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY) && !r_showsurfaces.integer)
13320                 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
13321         else if (!rsurface.texture->currentnumlayers)
13322                 return;
13323         else if (((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) || (r_showsurfaces.integer == 3 && (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST))) && queueentity)
13324         {
13325                 // in the deferred case, transparent surfaces were queued during prepass
13326                 if (!r_shadow_usingdeferredprepass)
13327                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
13328         }
13329         else
13330         {
13331                 // the alphatest check is to make sure we write depth for anything we skipped on the depth-only pass earlier
13332                 R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST), prepass);
13333         }
13334         CHECKGLERROR
13335 }
13336
13337 void R_QueueWorldSurfaceList(int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass)
13338 {
13339         int i, j;
13340         texture_t *texture;
13341         // break the surface list down into batches by texture and use of lightmapping
13342         for (i = 0;i < numsurfaces;i = j)
13343         {
13344                 j = i + 1;
13345                 // texture is the base texture pointer, rsurface.texture is the
13346                 // current frame/skin the texture is directing us to use (for example
13347                 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
13348                 // use skin 1 instead)
13349                 texture = surfacelist[i]->texture;
13350                 rsurface.texture = R_GetCurrentTexture(texture);
13351                 if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW))
13352                 {
13353                         // if this texture is not the kind we want, skip ahead to the next one
13354                         for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
13355                                 ;
13356                         continue;
13357                 }
13358                 if(FAKELIGHT_ENABLED || depthonly || prepass)
13359                 {
13360                         rsurface.lightmaptexture = NULL;
13361                         rsurface.deluxemaptexture = NULL;
13362                         rsurface.uselightmaptexture = false;
13363                         // simply scan ahead until we find a different texture or lightmap state
13364                         for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
13365                                 ;
13366                 }
13367                 else
13368                 {
13369                         rsurface.lightmaptexture = surfacelist[i]->lightmaptexture;
13370                         rsurface.deluxemaptexture = surfacelist[i]->deluxemaptexture;
13371                         rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL;
13372                         // simply scan ahead until we find a different texture or lightmap state
13373                         for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.lightmaptexture == surfacelist[j]->lightmaptexture;j++)
13374                                 ;
13375                 }
13376                 // render the range of surfaces
13377                 R_ProcessWorldTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, prepass);
13378         }
13379 }
13380
13381 static void R_ProcessModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, const entity_render_t *queueentity, qboolean prepass)
13382 {
13383         CHECKGLERROR
13384         if (depthonly)
13385                 R_DrawTextureSurfaceList_DepthOnly(texturenumsurfaces, texturesurfacelist);
13386         else if (prepass)
13387         {
13388                 if (!rsurface.texture->currentnumlayers)
13389                         return;
13390                 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
13391                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
13392                 else
13393                         R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
13394         }
13395         else if ((rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY) && !r_showsurfaces.integer)
13396                 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
13397         else if (!rsurface.texture->currentnumlayers)
13398                 return;
13399         else if (((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) || (r_showsurfaces.integer == 3 && (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST))) && queueentity)
13400         {
13401                 // in the deferred case, transparent surfaces were queued during prepass
13402                 if (!r_shadow_usingdeferredprepass)
13403                         R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
13404         }
13405         else
13406         {
13407                 // the alphatest check is to make sure we write depth for anything we skipped on the depth-only pass earlier
13408                 R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST), prepass);
13409         }
13410         CHECKGLERROR
13411 }
13412
13413 void R_QueueModelSurfaceList(entity_render_t *ent, int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass)
13414 {
13415         int i, j;
13416         texture_t *texture;
13417         // break the surface list down into batches by texture and use of lightmapping
13418         for (i = 0;i < numsurfaces;i = j)
13419         {
13420                 j = i + 1;
13421                 // texture is the base texture pointer, rsurface.texture is the
13422                 // current frame/skin the texture is directing us to use (for example
13423                 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
13424                 // use skin 1 instead)
13425                 texture = surfacelist[i]->texture;
13426                 rsurface.texture = R_GetCurrentTexture(texture);
13427                 if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW))
13428                 {
13429                         // if this texture is not the kind we want, skip ahead to the next one
13430                         for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
13431                                 ;
13432                         continue;
13433                 }
13434                 if(FAKELIGHT_ENABLED || depthonly || prepass)
13435                 {
13436                         rsurface.lightmaptexture = NULL;
13437                         rsurface.deluxemaptexture = NULL;
13438                         rsurface.uselightmaptexture = false;
13439                         // simply scan ahead until we find a different texture or lightmap state
13440                         for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
13441                                 ;
13442                 }
13443                 else
13444                 {
13445                         rsurface.lightmaptexture = surfacelist[i]->lightmaptexture;
13446                         rsurface.deluxemaptexture = surfacelist[i]->deluxemaptexture;
13447                         rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL;
13448                         // simply scan ahead until we find a different texture or lightmap state
13449                         for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.lightmaptexture == surfacelist[j]->lightmaptexture;j++)
13450                                 ;
13451                 }
13452                 // render the range of surfaces
13453                 R_ProcessModelTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, ent, prepass);
13454         }
13455 }
13456
13457 float locboxvertex3f[6*4*3] =
13458 {
13459         1,0,1, 1,0,0, 1,1,0, 1,1,1,
13460         0,1,1, 0,1,0, 0,0,0, 0,0,1,
13461         1,1,1, 1,1,0, 0,1,0, 0,1,1,
13462         0,0,1, 0,0,0, 1,0,0, 1,0,1,
13463         0,0,1, 1,0,1, 1,1,1, 0,1,1,
13464         1,0,0, 0,0,0, 0,1,0, 1,1,0
13465 };
13466
13467 unsigned short locboxelements[6*2*3] =
13468 {
13469          0, 1, 2, 0, 2, 3,
13470          4, 5, 6, 4, 6, 7,
13471          8, 9,10, 8,10,11,
13472         12,13,14, 12,14,15,
13473         16,17,18, 16,18,19,
13474         20,21,22, 20,22,23
13475 };
13476
13477 void R_DrawLoc_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
13478 {
13479         int i, j;
13480         cl_locnode_t *loc = (cl_locnode_t *)ent;
13481         vec3_t mins, size;
13482         float vertex3f[6*4*3];
13483         CHECKGLERROR
13484         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
13485         GL_DepthMask(false);
13486         GL_DepthRange(0, 1);
13487         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
13488         GL_DepthTest(true);
13489         GL_CullFace(GL_NONE);
13490         R_EntityMatrix(&identitymatrix);
13491
13492 //      R_Mesh_ResetTextureState();
13493
13494         i = surfacelist[0];
13495         GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f) * r_refdef.view.colorscale,
13496                          ((i & 0x0038) >> 3) * (1.0f / 7.0f) * r_refdef.view.colorscale,
13497                          ((i & 0x01C0) >> 6) * (1.0f / 7.0f) * r_refdef.view.colorscale,
13498                         surfacelist[0] < 0 ? 0.5f : 0.125f);
13499
13500         if (VectorCompare(loc->mins, loc->maxs))
13501         {
13502                 VectorSet(size, 2, 2, 2);
13503                 VectorMA(loc->mins, -0.5f, size, mins);
13504         }
13505         else
13506         {
13507                 VectorCopy(loc->mins, mins);
13508                 VectorSubtract(loc->maxs, loc->mins, size);
13509         }
13510
13511         for (i = 0;i < 6*4*3;)
13512                 for (j = 0;j < 3;j++, i++)
13513                         vertex3f[i] = mins[j] + size[j] * locboxvertex3f[i];
13514
13515         R_Mesh_PrepareVertices_Generic_Arrays(6*4, vertex3f, NULL, NULL);
13516         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
13517         R_Mesh_Draw(0, 6*4, 0, 6*2, NULL, NULL, 0, locboxelements, NULL, 0);
13518 }
13519
13520 void R_DrawLocs(void)
13521 {
13522         int index;
13523         cl_locnode_t *loc, *nearestloc;
13524         vec3_t center;
13525         nearestloc = CL_Locs_FindNearest(cl.movement_origin);
13526         for (loc = cl.locnodes, index = 0;loc;loc = loc->next, index++)
13527         {
13528                 VectorLerp(loc->mins, 0.5f, loc->maxs, center);
13529                 R_MeshQueue_AddTransparent(center, R_DrawLoc_Callback, (entity_render_t *)loc, loc == nearestloc ? -1 : index, NULL);
13530         }
13531 }
13532
13533 void R_DecalSystem_Reset(decalsystem_t *decalsystem)
13534 {
13535         if (decalsystem->decals)
13536                 Mem_Free(decalsystem->decals);
13537         memset(decalsystem, 0, sizeof(*decalsystem));
13538 }
13539
13540 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)
13541 {
13542         tridecal_t *decal;
13543         tridecal_t *decals;
13544         int i;
13545
13546         // expand or initialize the system
13547         if (decalsystem->maxdecals <= decalsystem->numdecals)
13548         {
13549                 decalsystem_t old = *decalsystem;
13550                 qboolean useshortelements;
13551                 decalsystem->maxdecals = max(16, decalsystem->maxdecals * 2);
13552                 useshortelements = decalsystem->maxdecals * 3 <= 65536;
13553                 decalsystem->decals = (tridecal_t *)Mem_Alloc(cls.levelmempool, decalsystem->maxdecals * (sizeof(tridecal_t) + sizeof(float[3][3]) + sizeof(float[3][2]) + sizeof(float[3][4]) + sizeof(int[3]) + (useshortelements ? sizeof(unsigned short[3]) : 0)));
13554                 decalsystem->color4f = (float *)(decalsystem->decals + decalsystem->maxdecals);
13555                 decalsystem->texcoord2f = (float *)(decalsystem->color4f + decalsystem->maxdecals*12);
13556                 decalsystem->vertex3f = (float *)(decalsystem->texcoord2f + decalsystem->maxdecals*6);
13557                 decalsystem->element3i = (int *)(decalsystem->vertex3f + decalsystem->maxdecals*9);
13558                 decalsystem->element3s = (useshortelements ? ((unsigned short *)(decalsystem->element3i + decalsystem->maxdecals*3)) : NULL);
13559                 if (decalsystem->numdecals)
13560                         memcpy(decalsystem->decals, old.decals, decalsystem->numdecals * sizeof(tridecal_t));
13561                 if (old.decals)
13562                         Mem_Free(old.decals);
13563                 for (i = 0;i < decalsystem->maxdecals*3;i++)
13564                         decalsystem->element3i[i] = i;
13565                 if (useshortelements)
13566                         for (i = 0;i < decalsystem->maxdecals*3;i++)
13567                                 decalsystem->element3s[i] = i;
13568         }
13569
13570         // grab a decal and search for another free slot for the next one
13571         decals = decalsystem->decals;
13572         decal = decalsystem->decals + (i = decalsystem->freedecal++);
13573         for (i = decalsystem->freedecal;i < decalsystem->numdecals && decals[i].color4ub[0][3];i++)
13574                 ;
13575         decalsystem->freedecal = i;
13576         if (decalsystem->numdecals <= i)
13577                 decalsystem->numdecals = i + 1;
13578
13579         // initialize the decal
13580         decal->lived = 0;
13581         decal->triangleindex = triangleindex;
13582         decal->surfaceindex = surfaceindex;
13583         decal->decalsequence = decalsequence;
13584         decal->color4ub[0][0] = (unsigned char)(c0[0]*255.0f);
13585         decal->color4ub[0][1] = (unsigned char)(c0[1]*255.0f);
13586         decal->color4ub[0][2] = (unsigned char)(c0[2]*255.0f);
13587         decal->color4ub[0][3] = 255;
13588         decal->color4ub[1][0] = (unsigned char)(c1[0]*255.0f);
13589         decal->color4ub[1][1] = (unsigned char)(c1[1]*255.0f);
13590         decal->color4ub[1][2] = (unsigned char)(c1[2]*255.0f);
13591         decal->color4ub[1][3] = 255;
13592         decal->color4ub[2][0] = (unsigned char)(c2[0]*255.0f);
13593         decal->color4ub[2][1] = (unsigned char)(c2[1]*255.0f);
13594         decal->color4ub[2][2] = (unsigned char)(c2[2]*255.0f);
13595         decal->color4ub[2][3] = 255;
13596         decal->vertex3f[0][0] = v0[0];
13597         decal->vertex3f[0][1] = v0[1];
13598         decal->vertex3f[0][2] = v0[2];
13599         decal->vertex3f[1][0] = v1[0];
13600         decal->vertex3f[1][1] = v1[1];
13601         decal->vertex3f[1][2] = v1[2];
13602         decal->vertex3f[2][0] = v2[0];
13603         decal->vertex3f[2][1] = v2[1];
13604         decal->vertex3f[2][2] = v2[2];
13605         decal->texcoord2f[0][0] = t0[0];
13606         decal->texcoord2f[0][1] = t0[1];
13607         decal->texcoord2f[1][0] = t1[0];
13608         decal->texcoord2f[1][1] = t1[1];
13609         decal->texcoord2f[2][0] = t2[0];
13610         decal->texcoord2f[2][1] = t2[1];
13611 }
13612
13613 extern cvar_t cl_decals_bias;
13614 extern cvar_t cl_decals_models;
13615 extern cvar_t cl_decals_newsystem_intensitymultiplier;
13616 // baseparms, parms, temps
13617 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)
13618 {
13619         int cornerindex;
13620         int index;
13621         float v[9][3];
13622         const float *vertex3f;
13623         int numpoints;
13624         float points[2][9][3];
13625         float temp[3];
13626         float tc[9][2];
13627         float f;
13628         float c[9][4];
13629         const int *e;
13630
13631         e = rsurface.modelelement3i + 3*triangleindex;
13632
13633         vertex3f = rsurface.modelvertex3f;
13634
13635         for (cornerindex = 0;cornerindex < 3;cornerindex++)
13636         {
13637                 index = 3*e[cornerindex];
13638                 VectorCopy(vertex3f + index, v[cornerindex]);
13639         }
13640         // cull backfaces
13641         //TriangleNormal(v[0], v[1], v[2], normal);
13642         //if (DotProduct(normal, localnormal) < 0.0f)
13643         //      continue;
13644         // clip by each of the box planes formed from the projection matrix
13645         // if anything survives, we emit the decal
13646         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]);
13647         if (numpoints < 3)
13648                 return;
13649         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]);
13650         if (numpoints < 3)
13651                 return;
13652         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]);
13653         if (numpoints < 3)
13654                 return;
13655         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]);
13656         if (numpoints < 3)
13657                 return;
13658         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]);
13659         if (numpoints < 3)
13660                 return;
13661         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]);
13662         if (numpoints < 3)
13663                 return;
13664         // some part of the triangle survived, so we have to accept it...
13665         if (dynamic)
13666         {
13667                 // dynamic always uses the original triangle
13668                 numpoints = 3;
13669                 for (cornerindex = 0;cornerindex < 3;cornerindex++)
13670                 {
13671                         index = 3*e[cornerindex];
13672                         VectorCopy(vertex3f + index, v[cornerindex]);
13673                 }
13674         }
13675         for (cornerindex = 0;cornerindex < numpoints;cornerindex++)
13676         {
13677                 // convert vertex positions to texcoords
13678                 Matrix4x4_Transform(projection, v[cornerindex], temp);
13679                 tc[cornerindex][0] = (temp[1]+1.0f)*0.5f * (s2-s1) + s1;
13680                 tc[cornerindex][1] = (temp[2]+1.0f)*0.5f * (t2-t1) + t1;
13681                 // calculate distance fade from the projection origin
13682                 f = a * (1.0f-fabs(temp[0])) * cl_decals_newsystem_intensitymultiplier.value;
13683                 f = bound(0.0f, f, 1.0f);
13684                 c[cornerindex][0] = r * f;
13685                 c[cornerindex][1] = g * f;
13686                 c[cornerindex][2] = b * f;
13687                 c[cornerindex][3] = 1.0f;
13688                 //VectorMA(v[cornerindex], cl_decals_bias.value, localnormal, v[cornerindex]);
13689         }
13690         if (dynamic)
13691                 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);
13692         else
13693                 for (cornerindex = 0;cornerindex < numpoints-2;cornerindex++)
13694                         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);
13695 }
13696 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)
13697 {
13698         matrix4x4_t projection;
13699         decalsystem_t *decalsystem;
13700         qboolean dynamic;
13701         dp_model_t *model;
13702         const msurface_t *surface;
13703         const msurface_t *surfaces;
13704         const int *surfacelist;
13705         const texture_t *texture;
13706         int numtriangles;
13707         int numsurfacelist;
13708         int surfacelistindex;
13709         int surfaceindex;
13710         int triangleindex;
13711         float localorigin[3];
13712         float localnormal[3];
13713         float localmins[3];
13714         float localmaxs[3];
13715         float localsize;
13716         //float normal[3];
13717         float planes[6][4];
13718         float angles[3];
13719         bih_t *bih;
13720         int bih_triangles_count;
13721         int bih_triangles[256];
13722         int bih_surfaces[256];
13723
13724         decalsystem = &ent->decalsystem;
13725         model = ent->model;
13726         if (!model || !ent->allowdecals || ent->alpha < 1 || (ent->flags & (RENDER_ADDITIVE | RENDER_NODEPTHTEST)))
13727         {
13728                 R_DecalSystem_Reset(&ent->decalsystem);
13729                 return;
13730         }
13731
13732         if (!model->brush.data_leafs && !cl_decals_models.integer)
13733         {
13734                 if (decalsystem->model)
13735                         R_DecalSystem_Reset(decalsystem);
13736                 return;
13737         }
13738
13739         if (decalsystem->model != model)
13740                 R_DecalSystem_Reset(decalsystem);
13741         decalsystem->model = model;
13742
13743         RSurf_ActiveModelEntity(ent, false, false, false);
13744
13745         Matrix4x4_Transform(&rsurface.inversematrix, worldorigin, localorigin);
13746         Matrix4x4_Transform3x3(&rsurface.inversematrix, worldnormal, localnormal);
13747         VectorNormalize(localnormal);
13748         localsize = worldsize*rsurface.inversematrixscale;
13749         localmins[0] = localorigin[0] - localsize;
13750         localmins[1] = localorigin[1] - localsize;
13751         localmins[2] = localorigin[2] - localsize;
13752         localmaxs[0] = localorigin[0] + localsize;
13753         localmaxs[1] = localorigin[1] + localsize;
13754         localmaxs[2] = localorigin[2] + localsize;
13755
13756         //VectorCopy(localnormal, planes[4]);
13757         //VectorVectors(planes[4], planes[2], planes[0]);
13758         AnglesFromVectors(angles, localnormal, NULL, false);
13759         AngleVectors(angles, planes[0], planes[2], planes[4]);
13760         VectorNegate(planes[0], planes[1]);
13761         VectorNegate(planes[2], planes[3]);
13762         VectorNegate(planes[4], planes[5]);
13763         planes[0][3] = DotProduct(planes[0], localorigin) - localsize;
13764         planes[1][3] = DotProduct(planes[1], localorigin) - localsize;
13765         planes[2][3] = DotProduct(planes[2], localorigin) - localsize;
13766         planes[3][3] = DotProduct(planes[3], localorigin) - localsize;
13767         planes[4][3] = DotProduct(planes[4], localorigin) - localsize;
13768         planes[5][3] = DotProduct(planes[5], localorigin) - localsize;
13769
13770 #if 1
13771 // works
13772 {
13773         matrix4x4_t forwardprojection;
13774         Matrix4x4_CreateFromQuakeEntity(&forwardprojection, localorigin[0], localorigin[1], localorigin[2], angles[0], angles[1], angles[2], localsize);
13775         Matrix4x4_Invert_Simple(&projection, &forwardprojection);
13776 }
13777 #else
13778 // broken
13779 {
13780         float projectionvector[4][3];
13781         VectorScale(planes[0], ilocalsize, projectionvector[0]);
13782         VectorScale(planes[2], ilocalsize, projectionvector[1]);
13783         VectorScale(planes[4], ilocalsize, projectionvector[2]);
13784         projectionvector[0][0] = planes[0][0] * ilocalsize;
13785         projectionvector[0][1] = planes[1][0] * ilocalsize;
13786         projectionvector[0][2] = planes[2][0] * ilocalsize;
13787         projectionvector[1][0] = planes[0][1] * ilocalsize;
13788         projectionvector[1][1] = planes[1][1] * ilocalsize;
13789         projectionvector[1][2] = planes[2][1] * ilocalsize;
13790         projectionvector[2][0] = planes[0][2] * ilocalsize;
13791         projectionvector[2][1] = planes[1][2] * ilocalsize;
13792         projectionvector[2][2] = planes[2][2] * ilocalsize;
13793         projectionvector[3][0] = -(localorigin[0]*projectionvector[0][0]+localorigin[1]*projectionvector[1][0]+localorigin[2]*projectionvector[2][0]);
13794         projectionvector[3][1] = -(localorigin[0]*projectionvector[0][1]+localorigin[1]*projectionvector[1][1]+localorigin[2]*projectionvector[2][1]);
13795         projectionvector[3][2] = -(localorigin[0]*projectionvector[0][2]+localorigin[1]*projectionvector[1][2]+localorigin[2]*projectionvector[2][2]);
13796         Matrix4x4_FromVectors(&projection, projectionvector[0], projectionvector[1], projectionvector[2], projectionvector[3]);
13797 }
13798 #endif
13799
13800         dynamic = model->surfmesh.isanimated;
13801         numsurfacelist = model->nummodelsurfaces;
13802         surfacelist = model->sortedmodelsurfaces;
13803         surfaces = model->data_surfaces;
13804
13805         bih = NULL;
13806         bih_triangles_count = -1;
13807         if(!dynamic)
13808         {
13809                 if(model->render_bih.numleafs)
13810                         bih = &model->render_bih;
13811                 else if(model->collision_bih.numleafs)
13812                         bih = &model->collision_bih;
13813         }
13814         if(bih)
13815                 bih_triangles_count = BIH_GetTriangleListForBox(bih, sizeof(bih_triangles) / sizeof(*bih_triangles), bih_triangles, bih_surfaces, localmins, localmaxs);
13816         if(bih_triangles_count == 0)
13817                 return;
13818         if(bih_triangles_count > (int) (sizeof(bih_triangles) / sizeof(*bih_triangles))) // hit too many, likely bad anyway
13819                 return;
13820         if(bih_triangles_count > 0)
13821         {
13822                 for (triangleindex = 0; triangleindex < bih_triangles_count; ++triangleindex)
13823                 {
13824                         surfaceindex = bih_surfaces[triangleindex];
13825                         surface = surfaces + surfaceindex;
13826                         texture = surface->texture;
13827                         if (texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SKY | MATERIALFLAG_SHORTDEPTHRANGE | MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
13828                                 continue;
13829                         if (texture->surfaceflags & Q3SURFACEFLAG_NOMARKS)
13830                                 continue;
13831                         R_DecalSystem_SplatTriangle(decalsystem, r, g, b, a, s1, t1, s2, t2, decalsequence, dynamic, planes, &projection, bih_triangles[triangleindex], surfaceindex);
13832                 }
13833         }
13834         else
13835         {
13836                 for (surfacelistindex = 0;surfacelistindex < numsurfacelist;surfacelistindex++)
13837                 {
13838                         surfaceindex = surfacelist[surfacelistindex];
13839                         surface = surfaces + surfaceindex;
13840                         // check cull box first because it rejects more than any other check
13841                         if (!dynamic && !BoxesOverlap(surface->mins, surface->maxs, localmins, localmaxs))
13842                                 continue;
13843                         // skip transparent surfaces
13844                         texture = surface->texture;
13845                         if (texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SKY | MATERIALFLAG_SHORTDEPTHRANGE | MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
13846                                 continue;
13847                         if (texture->surfaceflags & Q3SURFACEFLAG_NOMARKS)
13848                                 continue;
13849                         numtriangles = surface->num_triangles;
13850                         for (triangleindex = 0; triangleindex < numtriangles; triangleindex++)
13851                                 R_DecalSystem_SplatTriangle(decalsystem, r, g, b, a, s1, t1, s2, t2, decalsequence, dynamic, planes, &projection, triangleindex + surface->num_firsttriangle, surfaceindex);
13852                 }
13853         }
13854 }
13855
13856 // do not call this outside of rendering code - use R_DecalSystem_SplatEntities instead
13857 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)
13858 {
13859         int renderentityindex;
13860         float worldmins[3];
13861         float worldmaxs[3];
13862         entity_render_t *ent;
13863
13864         if (!cl_decals_newsystem.integer)
13865                 return;
13866
13867         worldmins[0] = worldorigin[0] - worldsize;
13868         worldmins[1] = worldorigin[1] - worldsize;
13869         worldmins[2] = worldorigin[2] - worldsize;
13870         worldmaxs[0] = worldorigin[0] + worldsize;
13871         worldmaxs[1] = worldorigin[1] + worldsize;
13872         worldmaxs[2] = worldorigin[2] + worldsize;
13873
13874         R_DecalSystem_SplatEntity(r_refdef.scene.worldentity, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence);
13875
13876         for (renderentityindex = 0;renderentityindex < r_refdef.scene.numentities;renderentityindex++)
13877         {
13878                 ent = r_refdef.scene.entities[renderentityindex];
13879                 if (!BoxesOverlap(ent->mins, ent->maxs, worldmins, worldmaxs))
13880                         continue;
13881
13882                 R_DecalSystem_SplatEntity(ent, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence);
13883         }
13884 }
13885
13886 typedef struct r_decalsystem_splatqueue_s
13887 {
13888         vec3_t worldorigin;
13889         vec3_t worldnormal;
13890         float color[4];
13891         float tcrange[4];
13892         float worldsize;
13893         int decalsequence;
13894 }
13895 r_decalsystem_splatqueue_t;
13896
13897 int r_decalsystem_numqueued = 0;
13898 r_decalsystem_splatqueue_t r_decalsystem_queue[MAX_DECALSYSTEM_QUEUE];
13899
13900 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)
13901 {
13902         r_decalsystem_splatqueue_t *queue;
13903
13904         if (!cl_decals_newsystem.integer || r_decalsystem_numqueued == MAX_DECALSYSTEM_QUEUE)
13905                 return;
13906
13907         queue = &r_decalsystem_queue[r_decalsystem_numqueued++];
13908         VectorCopy(worldorigin, queue->worldorigin);
13909         VectorCopy(worldnormal, queue->worldnormal);
13910         Vector4Set(queue->color, r, g, b, a);
13911         Vector4Set(queue->tcrange, s1, t1, s2, t2);
13912         queue->worldsize = worldsize;
13913         queue->decalsequence = cl.decalsequence++;
13914 }
13915
13916 static void R_DecalSystem_ApplySplatEntitiesQueue(void)
13917 {
13918         int i;
13919         r_decalsystem_splatqueue_t *queue;
13920
13921         for (i = 0, queue = r_decalsystem_queue;i < r_decalsystem_numqueued;i++, queue++)
13922                 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);
13923         r_decalsystem_numqueued = 0;
13924 }
13925
13926 extern cvar_t cl_decals_max;
13927 static void R_DrawModelDecals_FadeEntity(entity_render_t *ent)
13928 {
13929         int i;
13930         decalsystem_t *decalsystem = &ent->decalsystem;
13931         int numdecals;
13932         int killsequence;
13933         tridecal_t *decal;
13934         float frametime;
13935         float lifetime;
13936
13937         if (!decalsystem->numdecals)
13938                 return;
13939
13940         if (r_showsurfaces.integer)
13941                 return;
13942
13943         if (ent->model != decalsystem->model || ent->alpha < 1 || (ent->flags & RENDER_ADDITIVE))
13944         {
13945                 R_DecalSystem_Reset(decalsystem);
13946                 return;
13947         }
13948
13949         killsequence = cl.decalsequence - max(1, cl_decals_max.integer);
13950         lifetime = cl_decals_time.value + cl_decals_fadetime.value;
13951
13952         if (decalsystem->lastupdatetime)
13953                 frametime = (cl.time - decalsystem->lastupdatetime);
13954         else
13955                 frametime = 0;
13956         decalsystem->lastupdatetime = cl.time;
13957         decal = decalsystem->decals;
13958         numdecals = decalsystem->numdecals;
13959
13960         for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++)
13961         {
13962                 if (decal->color4ub[0][3])
13963                 {
13964                         decal->lived += frametime;
13965                         if (killsequence - decal->decalsequence > 0 || decal->lived >= lifetime)
13966                         {
13967                                 memset(decal, 0, sizeof(*decal));
13968                                 if (decalsystem->freedecal > i)
13969                                         decalsystem->freedecal = i;
13970                         }
13971                 }
13972         }
13973         decal = decalsystem->decals;
13974         while (numdecals > 0 && !decal[numdecals-1].color4ub[0][3])
13975                 numdecals--;
13976
13977         // collapse the array by shuffling the tail decals into the gaps
13978         for (;;)
13979         {
13980                 while (decalsystem->freedecal < numdecals && decal[decalsystem->freedecal].color4ub[0][3])
13981                         decalsystem->freedecal++;
13982                 if (decalsystem->freedecal == numdecals)
13983                         break;
13984                 decal[decalsystem->freedecal] = decal[--numdecals];
13985         }
13986
13987         decalsystem->numdecals = numdecals;
13988
13989         if (numdecals <= 0)
13990         {
13991                 // if there are no decals left, reset decalsystem
13992                 R_DecalSystem_Reset(decalsystem);
13993         }
13994 }
13995
13996 extern skinframe_t *decalskinframe;
13997 static void R_DrawModelDecals_Entity(entity_render_t *ent)
13998 {
13999         int i;
14000         decalsystem_t *decalsystem = &ent->decalsystem;
14001         int numdecals;
14002         tridecal_t *decal;
14003         float faderate;
14004         float alpha;
14005         float *v3f;
14006         float *c4f;
14007         float *t2f;
14008         const int *e;
14009         const unsigned char *surfacevisible = ent == r_refdef.scene.worldentity ? r_refdef.viewcache.world_surfacevisible : NULL;
14010         int numtris = 0;
14011
14012         numdecals = decalsystem->numdecals;
14013         if (!numdecals)
14014                 return;
14015
14016         if (r_showsurfaces.integer)
14017                 return;
14018
14019         if (ent->model != decalsystem->model || ent->alpha < 1 || (ent->flags & RENDER_ADDITIVE))
14020         {
14021                 R_DecalSystem_Reset(decalsystem);
14022                 return;
14023         }
14024
14025         // if the model is static it doesn't matter what value we give for
14026         // wantnormals and wanttangents, so this logic uses only rules applicable
14027         // to a model, knowing that they are meaningless otherwise
14028         if (ent == r_refdef.scene.worldentity)
14029                 RSurf_ActiveWorldEntity();
14030         else
14031                 RSurf_ActiveModelEntity(ent, false, false, false);
14032
14033         decalsystem->lastupdatetime = cl.time;
14034         decal = decalsystem->decals;
14035
14036         faderate = 1.0f / max(0.001f, cl_decals_fadetime.value);
14037
14038         // update vertex positions for animated models
14039         v3f = decalsystem->vertex3f;
14040         c4f = decalsystem->color4f;
14041         t2f = decalsystem->texcoord2f;
14042         for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++)
14043         {
14044                 if (!decal->color4ub[0][3])
14045                         continue;
14046
14047                 if (surfacevisible && !surfacevisible[decal->surfaceindex])
14048                         continue;
14049
14050                 // update color values for fading decals
14051                 if (decal->lived >= cl_decals_time.value)
14052                 {
14053                         alpha = 1 - faderate * (decal->lived - cl_decals_time.value);
14054                         alpha *= (1.0f/255.0f);
14055                 }
14056                 else
14057                         alpha = 1.0f/255.0f;
14058
14059                 c4f[ 0] = decal->color4ub[0][0] * alpha;
14060                 c4f[ 1] = decal->color4ub[0][1] * alpha;
14061                 c4f[ 2] = decal->color4ub[0][2] * alpha;
14062                 c4f[ 3] = 1;
14063                 c4f[ 4] = decal->color4ub[1][0] * alpha;
14064                 c4f[ 5] = decal->color4ub[1][1] * alpha;
14065                 c4f[ 6] = decal->color4ub[1][2] * alpha;
14066                 c4f[ 7] = 1;
14067                 c4f[ 8] = decal->color4ub[2][0] * alpha;
14068                 c4f[ 9] = decal->color4ub[2][1] * alpha;
14069                 c4f[10] = decal->color4ub[2][2] * alpha;
14070                 c4f[11] = 1;
14071
14072                 t2f[0] = decal->texcoord2f[0][0];
14073                 t2f[1] = decal->texcoord2f[0][1];
14074                 t2f[2] = decal->texcoord2f[1][0];
14075                 t2f[3] = decal->texcoord2f[1][1];
14076                 t2f[4] = decal->texcoord2f[2][0];
14077                 t2f[5] = decal->texcoord2f[2][1];
14078
14079                 // update vertex positions for animated models
14080                 if (decal->triangleindex >= 0 && decal->triangleindex < rsurface.modelnumtriangles)
14081                 {
14082                         e = rsurface.modelelement3i + 3*decal->triangleindex;
14083                         VectorCopy(rsurface.modelvertex3f + 3*e[0], v3f);
14084                         VectorCopy(rsurface.modelvertex3f + 3*e[1], v3f + 3);
14085                         VectorCopy(rsurface.modelvertex3f + 3*e[2], v3f + 6);
14086                 }
14087                 else
14088                 {
14089                         VectorCopy(decal->vertex3f[0], v3f);
14090                         VectorCopy(decal->vertex3f[1], v3f + 3);
14091                         VectorCopy(decal->vertex3f[2], v3f + 6);
14092                 }
14093
14094                 if (r_refdef.fogenabled)
14095                 {
14096                         alpha = RSurf_FogVertex(v3f);
14097                         VectorScale(c4f, alpha, c4f);
14098                         alpha = RSurf_FogVertex(v3f + 3);
14099                         VectorScale(c4f + 4, alpha, c4f + 4);
14100                         alpha = RSurf_FogVertex(v3f + 6);
14101                         VectorScale(c4f + 8, alpha, c4f + 8);
14102                 }
14103
14104                 v3f += 9;
14105                 c4f += 12;
14106                 t2f += 6;
14107                 numtris++;
14108         }
14109
14110         if (numtris > 0)
14111         {
14112                 r_refdef.stats.drawndecals += numtris;
14113
14114                 // now render the decals all at once
14115                 // (this assumes they all use one particle font texture!)
14116                 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);
14117 //              R_Mesh_ResetTextureState();
14118                 R_Mesh_PrepareVertices_Generic_Arrays(numtris * 3, decalsystem->vertex3f, decalsystem->color4f, decalsystem->texcoord2f);
14119                 GL_DepthMask(false);
14120                 GL_DepthRange(0, 1);
14121                 GL_PolygonOffset(rsurface.basepolygonfactor + r_polygonoffset_decals_factor.value, rsurface.basepolygonoffset + r_polygonoffset_decals_offset.value);
14122                 GL_DepthTest(true);
14123                 GL_CullFace(GL_NONE);
14124                 GL_BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
14125                 R_SetupShader_Generic(decalskinframe->base, NULL, GL_MODULATE, 1);
14126                 R_Mesh_Draw(0, numtris * 3, 0, numtris, decalsystem->element3i, NULL, 0, decalsystem->element3s, NULL, 0);
14127         }
14128 }
14129
14130 static void R_DrawModelDecals(void)
14131 {
14132         int i, numdecals;
14133
14134         // fade faster when there are too many decals
14135         numdecals = r_refdef.scene.worldentity->decalsystem.numdecals;
14136         for (i = 0;i < r_refdef.scene.numentities;i++)
14137                 numdecals += r_refdef.scene.entities[i]->decalsystem.numdecals;
14138
14139         R_DrawModelDecals_FadeEntity(r_refdef.scene.worldentity);
14140         for (i = 0;i < r_refdef.scene.numentities;i++)
14141                 if (r_refdef.scene.entities[i]->decalsystem.numdecals)
14142                         R_DrawModelDecals_FadeEntity(r_refdef.scene.entities[i]);
14143
14144         R_DecalSystem_ApplySplatEntitiesQueue();
14145
14146         numdecals = r_refdef.scene.worldentity->decalsystem.numdecals;
14147         for (i = 0;i < r_refdef.scene.numentities;i++)
14148                 numdecals += r_refdef.scene.entities[i]->decalsystem.numdecals;
14149
14150         r_refdef.stats.totaldecals += numdecals;
14151
14152         if (r_showsurfaces.integer)
14153                 return;
14154
14155         R_DrawModelDecals_Entity(r_refdef.scene.worldentity);
14156
14157         for (i = 0;i < r_refdef.scene.numentities;i++)
14158         {
14159                 if (!r_refdef.viewcache.entityvisible[i])
14160                         continue;
14161                 if (r_refdef.scene.entities[i]->decalsystem.numdecals)
14162                         R_DrawModelDecals_Entity(r_refdef.scene.entities[i]);
14163         }
14164 }
14165
14166 extern cvar_t mod_collision_bih;
14167 void R_DrawDebugModel(void)
14168 {
14169         entity_render_t *ent = rsurface.entity;
14170         int i, j, k, l, flagsmask;
14171         const msurface_t *surface;
14172         dp_model_t *model = ent->model;
14173         vec3_t v;
14174
14175         switch(vid.renderpath)
14176         {
14177         case RENDERPATH_GL11:
14178         case RENDERPATH_GL13:
14179         case RENDERPATH_GL20:
14180         case RENDERPATH_CGGL:
14181                 break;
14182         case RENDERPATH_D3D9:
14183                 //Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
14184                 return;
14185         case RENDERPATH_D3D10:
14186                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
14187                 return;
14188         case RENDERPATH_D3D11:
14189                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
14190                 return;
14191         }
14192
14193         flagsmask = MATERIALFLAG_SKY | MATERIALFLAG_WALL;
14194
14195 //      R_Mesh_ResetTextureState();
14196         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
14197         GL_DepthRange(0, 1);
14198         GL_DepthTest(!r_showdisabledepthtest.integer);
14199         GL_DepthMask(false);
14200         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
14201
14202         if (r_showcollisionbrushes.value > 0 && model->collision_bih.numleafs)
14203         {
14204                 int triangleindex;
14205                 int bihleafindex;
14206                 qboolean cullbox = ent == r_refdef.scene.worldentity;
14207                 const q3mbrush_t *brush;
14208                 const bih_t *bih = &model->collision_bih;
14209                 const bih_leaf_t *bihleaf;
14210                 float vertex3f[3][3];
14211                 GL_PolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);
14212                 cullbox = false;
14213                 for (bihleafindex = 0, bihleaf = bih->leafs;bihleafindex < bih->numleafs;bihleafindex++, bihleaf++)
14214                 {
14215                         if (cullbox && R_CullBox(bihleaf->mins, bihleaf->maxs))
14216                                 continue;
14217                         switch (bihleaf->type)
14218                         {
14219                         case BIH_BRUSH:
14220                                 brush = model->brush.data_brushes + bihleaf->itemindex;
14221                                 if (brush->colbrushf && brush->colbrushf->numtriangles)
14222                                 {
14223                                         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);
14224                                         R_Mesh_PrepareVertices_Generic_Arrays(brush->colbrushf->numpoints, brush->colbrushf->points->v, NULL, NULL);
14225                                         R_Mesh_Draw(0, brush->colbrushf->numpoints, 0, brush->colbrushf->numtriangles, brush->colbrushf->elements, NULL, 0, NULL, NULL, 0);
14226                                 }
14227                                 break;
14228                         case BIH_COLLISIONTRIANGLE:
14229                                 triangleindex = bihleaf->itemindex;
14230                                 VectorCopy(model->brush.data_collisionvertex3f + 3*model->brush.data_collisionelement3i[triangleindex*3+0], vertex3f[0]);
14231                                 VectorCopy(model->brush.data_collisionvertex3f + 3*model->brush.data_collisionelement3i[triangleindex*3+1], vertex3f[1]);
14232                                 VectorCopy(model->brush.data_collisionvertex3f + 3*model->brush.data_collisionelement3i[triangleindex*3+2], vertex3f[2]);
14233                                 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);
14234                                 R_Mesh_PrepareVertices_Generic_Arrays(3, vertex3f[0], NULL, NULL);
14235                                 R_Mesh_Draw(0, 3, 0, 1, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
14236                                 break;
14237                         case BIH_RENDERTRIANGLE:
14238                                 triangleindex = bihleaf->itemindex;
14239                                 VectorCopy(model->surfmesh.data_vertex3f + 3*model->surfmesh.data_element3i[triangleindex*3+0], vertex3f[0]);
14240                                 VectorCopy(model->surfmesh.data_vertex3f + 3*model->surfmesh.data_element3i[triangleindex*3+1], vertex3f[1]);
14241                                 VectorCopy(model->surfmesh.data_vertex3f + 3*model->surfmesh.data_element3i[triangleindex*3+2], vertex3f[2]);
14242                                 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);
14243                                 R_Mesh_PrepareVertices_Generic_Arrays(3, vertex3f[0], NULL, NULL);
14244                                 R_Mesh_Draw(0, 3, 0, 1, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
14245                                 break;
14246                         }
14247                 }
14248         }
14249
14250         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
14251
14252         if (r_showtris.integer || (r_shownormals.value != 0))
14253         {
14254                 if (r_showdisabledepthtest.integer)
14255                 {
14256                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
14257                         GL_DepthMask(false);
14258                 }
14259                 else
14260                 {
14261                         GL_BlendFunc(GL_ONE, GL_ZERO);
14262                         GL_DepthMask(true);
14263                 }
14264                 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
14265                 {
14266                         if (ent == r_refdef.scene.worldentity && !r_refdef.viewcache.world_surfacevisible[j])
14267                                 continue;
14268                         rsurface.texture = R_GetCurrentTexture(surface->texture);
14269                         if ((rsurface.texture->currentmaterialflags & flagsmask) && surface->num_triangles)
14270                         {
14271                                 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | BATCHNEED_NOGAPS, 1, &surface);
14272                                 if (r_showtris.value > 0)
14273                                 {
14274                                         if (!rsurface.texture->currentlayers->depthmask)
14275                                                 GL_Color(r_refdef.view.colorscale, 0, 0, r_showtris.value);
14276                                         else if (ent == r_refdef.scene.worldentity)
14277                                                 GL_Color(r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale, r_showtris.value);
14278                                         else
14279                                                 GL_Color(0, r_refdef.view.colorscale, 0, r_showtris.value);
14280                                         R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, NULL, NULL);
14281                                         qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
14282                                         RSurf_DrawBatch();
14283                                         qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
14284                                         CHECKGLERROR
14285                                 }
14286                                 if (r_shownormals.value < 0)
14287                                 {
14288                                         qglBegin(GL_LINES);
14289                                         for (k = 0, l = rsurface.batchfirstvertex;k < rsurface.batchnumvertices;k++, l++)
14290                                         {
14291                                                 VectorCopy(rsurface.batchvertex3f + l * 3, v);
14292                                                 GL_Color(0, 0, r_refdef.view.colorscale, 1);
14293                                                 qglVertex3f(v[0], v[1], v[2]);
14294                                                 VectorMA(v, -r_shownormals.value, rsurface.batchnormal3f + l * 3, v);
14295                                                 GL_Color(r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale, 1);
14296                                                 qglVertex3f(v[0], v[1], v[2]);
14297                                         }
14298                                         qglEnd();
14299                                         CHECKGLERROR
14300                                 }
14301                                 if (r_shownormals.value > 0 && rsurface.batchsvector3f)
14302                                 {
14303                                         qglBegin(GL_LINES);
14304                                         for (k = 0, l = rsurface.batchfirstvertex;k < rsurface.batchnumvertices;k++, l++)
14305                                         {
14306                                                 VectorCopy(rsurface.batchvertex3f + l * 3, v);
14307                                                 GL_Color(r_refdef.view.colorscale, 0, 0, 1);
14308                                                 qglVertex3f(v[0], v[1], v[2]);
14309                                                 VectorMA(v, r_shownormals.value, rsurface.batchsvector3f + l * 3, v);
14310                                                 GL_Color(r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale, 1);
14311                                                 qglVertex3f(v[0], v[1], v[2]);
14312                                         }
14313                                         qglEnd();
14314                                         CHECKGLERROR
14315                                         qglBegin(GL_LINES);
14316                                         for (k = 0, l = rsurface.batchfirstvertex;k < rsurface.batchnumvertices;k++, l++)
14317                                         {
14318                                                 VectorCopy(rsurface.batchvertex3f + l * 3, v);
14319                                                 GL_Color(0, r_refdef.view.colorscale, 0, 1);
14320                                                 qglVertex3f(v[0], v[1], v[2]);
14321                                                 VectorMA(v, r_shownormals.value, rsurface.batchtvector3f + l * 3, v);
14322                                                 GL_Color(r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale, 1);
14323                                                 qglVertex3f(v[0], v[1], v[2]);
14324                                         }
14325                                         qglEnd();
14326                                         CHECKGLERROR
14327                                         qglBegin(GL_LINES);
14328                                         for (k = 0, l = rsurface.batchfirstvertex;k < rsurface.batchnumvertices;k++, l++)
14329                                         {
14330                                                 VectorCopy(rsurface.batchvertex3f + l * 3, v);
14331                                                 GL_Color(0, 0, r_refdef.view.colorscale, 1);
14332                                                 qglVertex3f(v[0], v[1], v[2]);
14333                                                 VectorMA(v, r_shownormals.value, rsurface.batchnormal3f + l * 3, v);
14334                                                 GL_Color(r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale, 1);
14335                                                 qglVertex3f(v[0], v[1], v[2]);
14336                                         }
14337                                         qglEnd();
14338                                         CHECKGLERROR
14339                                 }
14340                         }
14341                 }
14342                 rsurface.texture = NULL;
14343         }
14344 }
14345
14346 extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
14347 int r_maxsurfacelist = 0;
14348 const msurface_t **r_surfacelist = NULL;
14349 void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass)
14350 {
14351         int i, j, endj, flagsmask;
14352         dp_model_t *model = r_refdef.scene.worldmodel;
14353         msurface_t *surfaces;
14354         unsigned char *update;
14355         int numsurfacelist = 0;
14356         if (model == NULL)
14357                 return;
14358
14359         if (r_maxsurfacelist < model->num_surfaces)
14360         {
14361                 r_maxsurfacelist = model->num_surfaces;
14362                 if (r_surfacelist)
14363                         Mem_Free((msurface_t**)r_surfacelist);
14364                 r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist));
14365         }
14366
14367         RSurf_ActiveWorldEntity();
14368
14369         surfaces = model->data_surfaces;
14370         update = model->brushq1.lightmapupdateflags;
14371
14372         // update light styles on this submodel
14373         if (!skysurfaces && !depthonly && !prepass && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
14374         {
14375                 model_brush_lightstyleinfo_t *style;
14376                 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
14377                 {
14378                         if (style->value != r_refdef.scene.lightstylevalue[style->style])
14379                         {
14380                                 int *list = style->surfacelist;
14381                                 style->value = r_refdef.scene.lightstylevalue[style->style];
14382                                 for (j = 0;j < style->numsurfaces;j++)
14383                                         update[list[j]] = true;
14384                         }
14385                 }
14386         }
14387
14388         flagsmask = skysurfaces ? MATERIALFLAG_SKY : MATERIALFLAG_WALL;
14389
14390         if (debug)
14391         {
14392                 R_DrawDebugModel();
14393                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
14394                 return;
14395         }
14396
14397         rsurface.lightmaptexture = NULL;
14398         rsurface.deluxemaptexture = NULL;
14399         rsurface.uselightmaptexture = false;
14400         rsurface.texture = NULL;
14401         rsurface.rtlight = NULL;
14402         numsurfacelist = 0;
14403         // add visible surfaces to draw list
14404         for (i = 0;i < model->nummodelsurfaces;i++)
14405         {
14406                 j = model->sortedmodelsurfaces[i];
14407                 if (r_refdef.viewcache.world_surfacevisible[j])
14408                         r_surfacelist[numsurfacelist++] = surfaces + j;
14409         }
14410         // update lightmaps if needed
14411         if (model->brushq1.firstrender)
14412         {
14413                 model->brushq1.firstrender = false;
14414                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
14415                         if (update[j])
14416                                 R_BuildLightMap(r_refdef.scene.worldentity, surfaces + j);
14417         }
14418         else if (update)
14419         {
14420                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
14421                         if (r_refdef.viewcache.world_surfacevisible[j])
14422                                 if (update[j])
14423                                         R_BuildLightMap(r_refdef.scene.worldentity, surfaces + j);
14424         }
14425         // don't do anything if there were no surfaces
14426         if (!numsurfacelist)
14427         {
14428                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
14429                 return;
14430         }
14431         R_QueueWorldSurfaceList(numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
14432         GL_AlphaTest(false);
14433
14434         // add to stats if desired
14435         if (r_speeds.integer && !skysurfaces && !depthonly)
14436         {
14437                 r_refdef.stats.world_surfaces += numsurfacelist;
14438                 for (j = 0;j < numsurfacelist;j++)
14439                         r_refdef.stats.world_triangles += r_surfacelist[j]->num_triangles;
14440         }
14441
14442         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
14443 }
14444
14445 void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass)
14446 {
14447         int i, j, endj, flagsmask;
14448         dp_model_t *model = ent->model;
14449         msurface_t *surfaces;
14450         unsigned char *update;
14451         int numsurfacelist = 0;
14452         if (model == NULL)
14453                 return;
14454
14455         if (r_maxsurfacelist < model->num_surfaces)
14456         {
14457                 r_maxsurfacelist = model->num_surfaces;
14458                 if (r_surfacelist)
14459                         Mem_Free((msurface_t **)r_surfacelist);
14460                 r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist));
14461         }
14462
14463         // if the model is static it doesn't matter what value we give for
14464         // wantnormals and wanttangents, so this logic uses only rules applicable
14465         // to a model, knowing that they are meaningless otherwise
14466         if (ent == r_refdef.scene.worldentity)
14467                 RSurf_ActiveWorldEntity();
14468         else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
14469                 RSurf_ActiveModelEntity(ent, false, false, false);
14470         else if (prepass)
14471                 RSurf_ActiveModelEntity(ent, true, true, true);
14472         else if (depthonly)
14473         {
14474                 switch (vid.renderpath)
14475                 {
14476                 case RENDERPATH_GL20:
14477                 case RENDERPATH_CGGL:
14478                 case RENDERPATH_D3D9:
14479                 case RENDERPATH_D3D10:
14480                 case RENDERPATH_D3D11:
14481                         RSurf_ActiveModelEntity(ent, model->wantnormals, model->wanttangents, false);
14482                         break;
14483                 case RENDERPATH_GL13:
14484                 case RENDERPATH_GL11:
14485                         RSurf_ActiveModelEntity(ent, model->wantnormals, false, false);
14486                         break;
14487                 }
14488         }
14489         else
14490         {
14491                 switch (vid.renderpath)
14492                 {
14493                 case RENDERPATH_GL20:
14494                 case RENDERPATH_CGGL:
14495                 case RENDERPATH_D3D9:
14496                 case RENDERPATH_D3D10:
14497                 case RENDERPATH_D3D11:
14498                         RSurf_ActiveModelEntity(ent, true, true, false);
14499                         break;
14500                 case RENDERPATH_GL13:
14501                 case RENDERPATH_GL11:
14502                         RSurf_ActiveModelEntity(ent, true, false, false);
14503                         break;
14504                 }
14505         }
14506
14507         surfaces = model->data_surfaces;
14508         update = model->brushq1.lightmapupdateflags;
14509
14510         // update light styles
14511         if (!skysurfaces && !depthonly && !prepass && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
14512         {
14513                 model_brush_lightstyleinfo_t *style;
14514                 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
14515                 {
14516                         if (style->value != r_refdef.scene.lightstylevalue[style->style])
14517                         {
14518                                 int *list = style->surfacelist;
14519                                 style->value = r_refdef.scene.lightstylevalue[style->style];
14520                                 for (j = 0;j < style->numsurfaces;j++)
14521                                         update[list[j]] = true;
14522                         }
14523                 }
14524         }
14525
14526         flagsmask = skysurfaces ? MATERIALFLAG_SKY : MATERIALFLAG_WALL;
14527
14528         if (debug)
14529         {
14530                 R_DrawDebugModel();
14531                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
14532                 return;
14533         }
14534
14535         rsurface.lightmaptexture = NULL;
14536         rsurface.deluxemaptexture = NULL;
14537         rsurface.uselightmaptexture = false;
14538         rsurface.texture = NULL;
14539         rsurface.rtlight = NULL;
14540         numsurfacelist = 0;
14541         // add visible surfaces to draw list
14542         for (i = 0;i < model->nummodelsurfaces;i++)
14543                 r_surfacelist[numsurfacelist++] = surfaces + model->sortedmodelsurfaces[i];
14544         // don't do anything if there were no surfaces
14545         if (!numsurfacelist)
14546         {
14547                 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
14548                 return;
14549         }
14550         // update lightmaps if needed
14551         if (update)
14552         {
14553                 int updated = 0;
14554                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
14555                 {
14556                         if (update[j])
14557                         {
14558                                 updated++;
14559                                 R_BuildLightMap(ent, surfaces + j);
14560                         }
14561                 }
14562         }
14563         if (update)
14564                 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
14565                         if (update[j])
14566                                 R_BuildLightMap(ent, surfaces + j);
14567         R_QueueModelSurfaceList(ent, numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
14568         GL_AlphaTest(false);
14569
14570         // add to stats if desired
14571         if (r_speeds.integer && !skysurfaces && !depthonly)
14572         {
14573                 r_refdef.stats.entities_surfaces += numsurfacelist;
14574                 for (j = 0;j < numsurfacelist;j++)
14575                         r_refdef.stats.entities_triangles += r_surfacelist[j]->num_triangles;
14576         }
14577
14578         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
14579 }
14580
14581 void R_DrawCustomSurface(skinframe_t *skinframe, const matrix4x4_t *texmatrix, int materialflags, int firstvertex, int numvertices, int firsttriangle, int numtriangles, qboolean writedepth, qboolean prepass)
14582 {
14583         static texture_t texture;
14584         static msurface_t surface;
14585         const msurface_t *surfacelist = &surface;
14586
14587         // fake enough texture and surface state to render this geometry
14588
14589         texture.update_lastrenderframe = -1; // regenerate this texture
14590         texture.basematerialflags = materialflags | MATERIALFLAG_CUSTOMSURFACE | MATERIALFLAG_WALL;
14591         texture.currentskinframe = skinframe;
14592         texture.currenttexmatrix = *texmatrix; // requires MATERIALFLAG_CUSTOMSURFACE
14593         texture.offsetmapping = OFFSETMAPPING_OFF;
14594         texture.offsetscale = 1;
14595         texture.specularscalemod = 1;
14596         texture.specularpowermod = 1;
14597
14598         surface.texture = &texture;
14599         surface.num_triangles = numtriangles;
14600         surface.num_firsttriangle = firsttriangle;
14601         surface.num_vertices = numvertices;
14602         surface.num_firstvertex = firstvertex;
14603
14604         // now render it
14605         rsurface.texture = R_GetCurrentTexture(surface.texture);
14606         rsurface.lightmaptexture = NULL;
14607         rsurface.deluxemaptexture = NULL;
14608         rsurface.uselightmaptexture = false;
14609         R_DrawModelTextureSurfaceList(1, &surfacelist, writedepth, prepass);
14610 }
14611
14612 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)
14613 {
14614         static msurface_t surface;
14615         const msurface_t *surfacelist = &surface;
14616
14617         // fake enough texture and surface state to render this geometry
14618         surface.texture = texture;
14619         surface.num_triangles = numtriangles;
14620         surface.num_firsttriangle = firsttriangle;
14621         surface.num_vertices = numvertices;
14622         surface.num_firstvertex = firstvertex;
14623
14624         // now render it
14625         rsurface.texture = R_GetCurrentTexture(surface.texture);
14626         rsurface.lightmaptexture = NULL;
14627         rsurface.deluxemaptexture = NULL;
14628         rsurface.uselightmaptexture = false;
14629         R_DrawModelTextureSurfaceList(1, &surfacelist, writedepth, prepass);
14630 }